मैंने एक साथ कुछ उदाहरण टेंसोफ़्लो कोड को समझाने में मदद करने के लिए रखा है (पूर्ण, काम करने वाला कोड इस गिस्ट में है )। यह कोड आपके द्वारा लिंक किए गए पेपर में अनुभाग 2 के पहले भाग से कैप्सूल नेटवर्क को लागू करता है:
N_REC_UNITS = 10
N_GEN_UNITS = 20
N_CAPSULES = 30
# input placeholders
img_input_flat = tf.placeholder(tf.float32, shape=(None, 784))
d_xy = tf.placeholder(tf.float32, shape=(None, 2))
# translate the image according to d_xy
img_input = tf.reshape(img_input_flat, (-1, 28, 28, 1))
trans_img = image.translate(img_input, d_xy)
flat_img = tf.layers.flatten(trans_img)
capsule_img_list = []
# build several capsules and store the generated output in a list
for i in range(N_CAPSULES):
# hidden recognition layer
h_rec = tf.layers.dense(flat_img, N_REC_UNITS, activation=tf.nn.relu)
# inferred xy values
xy = tf.layers.dense(h_rec, 2) + d_xy
# inferred probability of feature
p = tf.layers.dense(h_rec, 1, activation=tf.nn.sigmoid)
# hidden generative layer
h_gen = tf.layers.dense(xy, N_GEN_UNITS, activation=tf.nn.relu)
# the flattened generated image
cap_img = p*tf.layers.dense(h_gen, 784, activation=tf.nn.relu)
capsule_img_list.append(cap_img)
# combine the generated images
gen_img_stack = tf.stack(capsule_img_list, axis=1)
gen_img = tf.reduce_sum(gen_img_stack, axis=1)
क्या किसी को पता है कि इनपुट पिक्सल से कैप्सूल के बीच की मैपिंग कैसे काम करनी चाहिए?
यह नेटवर्क संरचना पर निर्भर करता है। उस कागज़ (और ऊपर दिए गए कोड) में पहले प्रयोग के लिए, प्रत्येक कैप्सूल में एक ग्रहणशील क्षेत्र होता है जिसमें संपूर्ण इनपुट छवि शामिल होती है। वह सबसे सरल व्यवस्था है। उस स्थिति में, यह इनपुट छवि और प्रत्येक कैप्सूल में पहली छिपी परत के बीच एक पूरी तरह से जुड़ा हुआ परत है।
वैकल्पिक रूप से, कैप्सूल ग्रहणशील क्षेत्रों को स्ट्रिप के साथ सीएनएन गुठली की तरह अधिक व्यवस्थित किया जा सकता है, जैसा कि उस पेपर में बाद के प्रयोगों में है।
मान्यता इकाइयों में वास्तव में क्या होना चाहिए?
मान्यता इकाइयां एक आंतरिक प्रतिनिधित्व है जो प्रत्येक कैप्सूल में है। प्रत्येक कैप्सूल इस आंतरिक प्रतिनिधित्व का उपयोग गणना करने के लिए करता है p, संभावना है कि कैप्सूल की सुविधा मौजूद है, और xy, अनुमान अनुवाद मूल्यों। उस पेपर में चित्र 2 यह सुनिश्चित करने के लिए एक जांच है कि नेटवर्क xyसही तरीके से उपयोग करना सीख रहा है (यह है)।
इसे कैसे प्रशिक्षित किया जाना चाहिए? क्या यह हर कनेक्शन के बीच सिर्फ मानक बैक प्रोप है?
विशेष रूप से, आपको इसे जेनरेट किए गए आउटपुट और मूल के बीच समानता को लागू करने वाले नुकसान का उपयोग करते हुए, एक ऑटोकेनर के रूप में प्रशिक्षित करना चाहिए। माध्य वर्ग त्रुटि यहाँ अच्छी तरह से काम करती है। इसके अलावा, हां, आपको बैकप्रॉप के साथ ढाल वंश को प्रचारित करने की आवश्यकता होगी।
loss = tf.losses.mean_squared_error(img_input_flat, gen_img)
train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)