मैं केवल एक छिपी हुई परत के साथ एक सामान्य तंत्रिका नेटवर्क के साथ खेल रहा था, टेंसोफ़्लो द्वारा, और फिर मैंने छिपी हुई छिपकली के लिए अलग सक्रियता की कोशिश की:
- Relu
- अवग्रह
- सॉफ्टमैक्स (अच्छी तरह से, आमतौर पर सॉफ्टमैक्स का उपयोग अंतिम परत में किया जाता है ..)
रेलू बेहतरीन ट्रेन सटीकता और सत्यापन सटीकता देता है। मुझे यकीन नहीं है कि यह कैसे समझा जाए।
हम जानते हैं कि रेलू में अच्छे गुण हैं, जैसे कि स्पार्सिटी, जैसे कि नो-ग्रेडिएंट-वैनिशिंग, आदि, लेकिन
प्रश्न: सामान्य तौर पर सिग्मॉइड / सॉफ्टमैक्स न्यूरॉन्स की तुलना में रिलु न्यूरॉन बेहतर है? क्या हमें एनएन (या यहां तक कि सीएनएन) में लगभग हमेशा रिले न्यूरॉन्स का उपयोग करना चाहिए? मुझे लगा कि अगर हम ओवरफिटिंग के बारे में चिंता करते हैं तो एक अधिक जटिल न्यूरॉन कम से कम ट्रेन सटीकता को बेहतर परिणाम देगा।
धन्यवाद PS: मूल रूप से कोड "Udacity-Machine Learning -assignment2" से है, जो कि साधारण 1-हिडन-लेयर-NN का उपयोग करते हुए notMNIST की मान्यता है।
batch_size = 128
graph = tf.Graph()
with graph.as_default():
# Input data.
tf_train_dataset = tf.placeholder(tf.float32, shape=(batch_size, image_size * image_size))
tf_train_labels = tf.placeholder(tf.float32, shape=(batch_size, num_labels))
tf_valid_dataset = tf.constant(valid_dataset)
tf_test_dataset = tf.constant(test_dataset)
# hidden layer
hidden_nodes = 1024
hidden_weights = tf.Variable( tf.truncated_normal([image_size * image_size, hidden_nodes]) )
hidden_biases = tf.Variable( tf.zeros([hidden_nodes]))
hidden_layer = **tf.nn.relu**( tf.matmul( tf_train_dataset, hidden_weights) + hidden_biases)
# Variables.
weights = tf.Variable( tf.truncated_normal([hidden_nodes, num_labels]))
biases = tf.Variable(tf.zeros([num_labels]))
# Training computation.
logits = tf.matmul(hidden_layer, weights) + biases
loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits, tf_train_labels) )
# Optimizer.
optimizer = tf.train.GradientDescentOptimizer(0.5).minimize(loss)
# Predictions for the training, validation, and test data.
train_prediction = tf.nn.softmax(logits)
valid_relu = **tf.nn.relu**( tf.matmul(tf_valid_dataset, hidden_weights) + hidden_biases)
valid_prediction = tf.nn.softmax( tf.matmul(valid_relu, weights) + biases)
test_relu = **tf.nn.relu**( tf.matmul( tf_test_dataset, hidden_weights) + hidden_biases)
test_prediction = tf.nn.softmax(tf.matmul(test_relu, weights) + biases)