मैं अपने Caffe नेटवर्क को TensorFlow पर पोर्ट कर रहा हूं, लेकिन इसमें जेवियर इनिशियलाइजेशन नहीं है। मैं उपयोग कर रहा हूं, truncated_normalलेकिन ऐसा लगता है कि इसे प्रशिक्षित करना बहुत कठिन है।
जवाबों:
में Tensorflow 2.0 और आगे दोनों tf.contrib.*और tf.get_variable()पदावनत कर रहे हैं। ज़ेवियर इनिशियलाइज़ेशन को करने के लिए आपको अब इस पर स्विच करना होगा:
init = tf.initializers.GlorotUniform()
var = tf.Variable(init(shape=shape))
# or a oneliner with a little confusing brackets
var = tf.Variable(tf.initializers.GlorotUniform()(shape=shape))
ग्लोरोट वर्दी और ज़ेवियर वर्दी एक ही प्रारंभिक प्रकार के दो अलग-अलग नाम हैं। यदि आप केएआर के साथ या दस्तावेज के बिना TF2.0 में इनिशियलाइज़ेशन का उपयोग करने के तरीके के बारे में अधिक जानना चाहते हैं ।
चूंकि संस्करण 0.8 में जेवियर इनिशियलाइज़र है, डॉक्स के लिए यहां देखें ।
आप इस तरह से कुछ का उपयोग कर सकते हैं:
W = tf.get_variable("W", shape=[784, 256],
initializer=tf.contrib.layers.xavier_initializer())
get_variableलेकिन इसे इनिशियलाइज़र को देने के बजाय? मेरे पास होता था tf.truncated_normal(shape=[dims[l-1],dims[l]], mean=mu[l], stddev=std[l], dtype=tf.float64)और मैंने वहां आकार निर्दिष्ट किया था, लेकिन अब आपके सुझाव ने मेरे कोड को खराब कर दिया है। क्या तुम्हारे पास कोई सुझाव है?
tf.Variable(...)और उपयोग करता हैtf.get_variable(...)
बस एक और उदाहरण जोड़ना है कि ज़ेवियर और योशुआ की विधि tf.Variableका उपयोग करते हुए कैसे परिभाषित किया जाए :
graph = tf.Graph()
with graph.as_default():
...
initializer = tf.contrib.layers.xavier_initializer()
w1 = tf.Variable(initializer(w1_shape))
b1 = tf.Variable(initializer(b1_shape))
...
इसने मुझे nanRELUs के साथ कई परतों का उपयोग करते समय संख्यात्मक अस्थिरताओं के कारण मेरे नुकसान फ़ंक्शन पर मान रखने से रोका ।
@ एलेफ 7, जेवियर / ग्लोरोट आरंभीकरण आने वाले कनेक्शनों की संख्या (फैन_इन), नंबर आउटगोइंग कनेक्शन (फैन_आउट) और न्यूरॉन की तरह का सक्रियण फ़ंक्शन (सिग्मॉइड या टैन) निर्भर करता है। इसे देखें: http://jmlr.org/proceedings/papers/v9/glorot10a/glorot10a.bdf
तो अब, आपके प्रश्न के लिए। यह मैं इसे TensorFlow में कैसे करूंगा:
(fan_in, fan_out) = ...
low = -4*np.sqrt(6.0/(fan_in + fan_out)) # use 4 for sigmoid, 1 for tanh activation
high = 4*np.sqrt(6.0/(fan_in + fan_out))
return tf.Variable(tf.random_uniform(shape, minval=low, maxval=high, dtype=tf.float32))
ध्यान दें कि हमें समान वितरण से नमूना होना चाहिए, न कि सामान्य वितरण जैसा कि अन्य उत्तर में दिया गया है।
संयोग से, मैंने कल TensorFlow का उपयोग करते हुए कुछ अलग करने के लिए एक पोस्ट लिखा था जो जेवियर इनिशियलाइज़ेशन का उपयोग करने के लिए भी होता है। यदि आप रुचि रखते हैं, तो एंड-टू-एंड उदाहरण के साथ एक अजगर नोटबुक भी है: https://github.com/delip/blog-stuff/blob/master/tensorflow_ufp.ipynb
tensorflowबुलाया चारों ओर एक अच्छा आवरण prettytensorस्रोत कोड में एक कार्यान्वयन देता है (सीधे यहाँ से कॉपी किया गया ):
def xavier_init(n_inputs, n_outputs, uniform=True):
"""Set the parameter initialization using the method described.
This method is designed to keep the scale of the gradients roughly the same
in all layers.
Xavier Glorot and Yoshua Bengio (2010):
Understanding the difficulty of training deep feedforward neural
networks. International conference on artificial intelligence and
statistics.
Args:
n_inputs: The number of input nodes into each output.
n_outputs: The number of output nodes for each input.
uniform: If true use a uniform distribution, otherwise use a normal.
Returns:
An initializer.
"""
if uniform:
# 6 was used in the paper.
init_range = math.sqrt(6.0 / (n_inputs + n_outputs))
return tf.random_uniform_initializer(-init_range, init_range)
else:
# 3 gives us approximately the same limits as above since this repicks
# values greater than 2 standard deviations from the mean.
stddev = math.sqrt(3.0 / (n_inputs + n_outputs))
return tf.truncated_normal_initializer(stddev=stddev)
TF-contrib है xavier_initializer। इसका उपयोग करने का एक उदाहरण इस प्रकार है:
import tensorflow as tf
a = tf.get_variable("a", shape=[4, 4], initializer=tf.contrib.layers.xavier_initializer())
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
print sess.run(a)
इसके अतिरिक्त, टेंसोफ़्लो में अन्य इनिशियलाइज़र हैं:
मैंने देखा और मुझे इसमें निर्मित कुछ भी नहीं मिला। हालांकि, इसके अनुसार:
http://andyljones.tumblr.com/post/110998971763/an-explanation-of-xavier-initialization
ज़ेवियर इनिशियलाइज़ेशन केवल (आमतौर पर गॉसियन) वितरण का नमूना है जहाँ विचरण न्यूरॉन्स की संख्या का एक कार्य है। tf.random_normalआपके लिए ऐसा कर सकते हैं, आपको बस stddev की गणना करने की आवश्यकता है (यानी वजन मैट्रिक्स द्वारा दर्शाए जा रहे न्यूरॉन्स की संख्या जिसे आप शुरू करने की कोशिश कर रहे हैं)।
आदि को kernel_initializerपैरामीटर के माध्यम सेtf.layers.conv2d, tf.layers.conv2d_transpose, tf.layers.Dense
जैसे
layer = tf.layers.conv2d(
input, 128, 5, strides=2,padding='SAME',
kernel_initializer=tf.contrib.layers.xavier_initializer())
https://www.tensorflow.org/api_docs/python/tf/layers/conv2d
https://www.tensorflow.org/api_docs/python/tf/layers/conv2d_transpose