2016-02-08 6 views
14

के लिए टेंसरफ्लो मैं बाइनरी वर्गीकरण के लिए this MNIST example को अनुकूलित करने की कोशिश कर रहा हूं।बाइनरी वर्गीकरण

लेकिन से NLABELS=2 से NLABELS=1 पर बदलते समय, हानि फ़ंक्शन हमेशा 0 (और सटीकता 1) देता है।

from __future__ import absolute_import 
from __future__ import division 
from __future__ import print_function 

from tensorflow.examples.tutorials.mnist import input_data 
import tensorflow as tf 

# Import data 
mnist = input_data.read_data_sets('data', one_hot=True) 
NLABELS = 2 

sess = tf.InteractiveSession() 

# Create the model 
x = tf.placeholder(tf.float32, [None, 784], name='x-input') 
W = tf.Variable(tf.zeros([784, NLABELS]), name='weights') 
b = tf.Variable(tf.zeros([NLABELS], name='bias')) 

y = tf.nn.softmax(tf.matmul(x, W) + b) 

# Add summary ops to collect data 
_ = tf.histogram_summary('weights', W) 
_ = tf.histogram_summary('biases', b) 
_ = tf.histogram_summary('y', y) 

# Define loss and optimizer 
y_ = tf.placeholder(tf.float32, [None, NLABELS], name='y-input') 

# More name scopes will clean up the graph representation 
with tf.name_scope('cross_entropy'): 
    cross_entropy = -tf.reduce_mean(y_ * tf.log(y)) 
    _ = tf.scalar_summary('cross entropy', cross_entropy) 
with tf.name_scope('train'): 
    train_step = tf.train.GradientDescentOptimizer(10.).minimize(cross_entropy) 

with tf.name_scope('test'): 
    correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1)) 
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) 
    _ = tf.scalar_summary('accuracy', accuracy) 

# Merge all the summaries and write them out to /tmp/mnist_logs 
merged = tf.merge_all_summaries() 
writer = tf.train.SummaryWriter('logs', sess.graph_def) 
tf.initialize_all_variables().run() 

# Train the model, and feed in test data and record summaries every 10 steps 

for i in range(1000): 
    if i % 10 == 0: # Record summary data and the accuracy 
     labels = mnist.test.labels[:, 0:NLABELS] 
     feed = {x: mnist.test.images, y_: labels} 

     result = sess.run([merged, accuracy, cross_entropy], feed_dict=feed) 
     summary_str = result[0] 
     acc = result[1] 
     loss = result[2] 
     writer.add_summary(summary_str, i) 
     print('Accuracy at step %s: %s - loss: %f' % (i, acc, loss)) 
    else: 
     batch_xs, batch_ys = mnist.train.next_batch(100) 
     batch_ys = batch_ys[:, 0:NLABELS] 
     feed = {x: batch_xs, y_: batch_ys} 
    sess.run(train_step, feed_dict=feed) 

मैं दोनों batch_ys (y में खिलाया) और _y के आयामों की जाँच कर ली है और वे दोनों 1xN मैट्रिक्स जब NLABELS=1 तो समस्या यह है कि करने से पहले हो रहा है कर रहे हैं। शायद मैट्रिक्स गुणा के साथ कुछ करने के लिए?

मुझे वास्तव में एक असली परियोजना में एक ही समस्या है, इसलिए किसी भी मदद की सराहना की जाएगी ... धन्यवाद!

+0

मैं आपके नेटwrok की कोशिश कर रहा हूं और यह काम नहीं कर रहा है, क्या आपको एक संभावित समाधान मिला है? –

उत्तर

33

मूल MNIST उदाहरण एक one-hot encoding का उपयोग करता है डेटा में लेबल का प्रतिनिधित्व करने के लिए: इसका मतलब है कि अगर वहाँ NLABELS = 10 वर्ग हैं (MNIST के रूप में), लक्ष्य उत्पादन कक्षा 1, आदि के लिए वर्ग 0 के लिए [1 0 0 0 0 0 0 0 0 0], [0 1 0 0 0 0 0 0 0 0] है tf.nn.softmax() ऑपरेटर विभिन्न आउटपुट कक्षाओं में संभाव्यता वितरण में tf.matmul(x, W) + b द्वारा गणना किए गए लॉग इन को परिवर्तित करता है, जिसे y_ के लिए फेड-इन मान की तुलना में किया जाता है।

तो NLABELS = 1, इस कार्य करता है के रूप में अगर वहाँ केवल एक ही वर्ग के थे, और tf.nn.softmax() सेशन उस वर्ग के लिए 1.0 की सम्भावना परिकलित किया जाएगा, 0.0 की एक क्रोस एंट्रोपी के लिए अग्रणी, के बाद से tf.log(1.0) उदाहरण के सभी के लिए 0.0 है ।

रहे हैं दो दृष्टिकोण (कम से कम) आप द्विआधारी वर्गीकरण के लिए कोशिश कर सकते:

  1. सरल दो संभव कक्षाओं के लिए NLABELS = 2 निर्धारित करते हैं, और लेबल 0 के लिए [1 0] के रूप में अपने प्रशिक्षण डेटा एन्कोड करने के लिए हो सकता है और लेबल के लिए [0 1] 1. This answer में ऐसा करने के लिए एक सुझाव है।

  2. आप पूर्णांकों 0 और 1 के रूप में लेबल रखने के लिए और के रूप में this answer में सुझाव दिया tf.nn.sparse_softmax_cross_entropy_with_logits() उपयोग करते हैं, कर सकते हैं।

+0

ओह, मुझे समस्या दिखाई दे रही है ... लेकिन अब मुझे आश्चर्य है, क्या मुझे बाइनरी वर्गीकरण समस्या के लिए क्रॉस एन्ट्रॉपी का उपयोग करना चाहिए? इस लड़के ने हाथ से एक तंत्रिका नेटवर्क लागू किया है, उसने अपनी बाइनरी वर्गीकरण समस्या के लिए क्रॉस एन्ट्रॉपी का उपयोग नहीं किया है: http://iamtrask.github.io/2015/07/12/basic-python-network/ –

+0

यह निश्चित रूप से संभव है। आपके पास एक आउटपुट इकाई हो सकती है, इसे 0 और 1 के बीच मान प्राप्त करने के लिए 'tf.nn.sigmoid()' के माध्यम से फ़ीड करें और फिर 'y-y_' को हानि फ़ंक्शन के रूप में उपयोग करें। – mrry

+1

TensorFlow हानि फ़ंक्शन को कम करने का प्रयास नहीं करता है? यह एक स्केलर होना चाहिए, है ना? क्या मुझे कुछ राशि चाहिए (abs (abs-y-y _)) '? –

संबंधित मुद्दे