tensorflow

Question

में संकल्पक परत के आउटपुट को विज़ुअलाइज़ करना मैं tf.image_summary फ़ंक्शन का उपयोग करके टेंसरफ़्लो में एक संकल्पक परत के आउटपुट को विज़ुअलाइज़ करने का प्रयास कर रहा हूं। मैं पहले से ही अन्य उदाहरणों में सफलतापूर्वक इसका उपयोग कर रहा हूं (ई। जी। इनपुट छवि को विज़ुअलाइज़ करना), लेकिन यहां कुछ आउटपुट को सही ढंग से आउटपुट को दोबारा बदलना है।

img_size = 256 
x_image = tf.reshape(x, [-1,img_size, img_size,1], "sketch_image") 

W_conv1 = weight_variable([5, 5, 1, 32]) 
b_conv1 = bias_variable([32]) 

h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1) 

तो h_conv1 के उत्पादन में आकार [-1, img_size, img_size, 32] होगा: मैं निम्नलिखित रूपा परत होती है। बस tf.image_summary("first_conv", tf.reshape(h_conv1, [-1, img_size, img_size, 1])) का उपयोग 32 अलग-अलग कर्नेल के लिए खाता नहीं है, इसलिए मैं मूल रूप से विभिन्न फीचर मैप्स के माध्यम से टुकड़ा कर रहा हूं।

मैं उन्हें सही तरीके से दोबारा कैसे बदल सकता हूं? या क्या सारांश में इस आउटपुट को शामिल करने के लिए मैं एक और सहायक कार्य कर सकता हूं?

Answer 1

मुझे एक सहायक कार्य के बारे में पता नहीं है, लेकिन यदि आप सभी फ़िल्टर देखना चाहते हैं तो आप उन्हें tf.transpose के कुछ फैंसी उपयोगों के साथ एक छवि में पैक कर सकते हैं।

तो तुम एक टेन्सर है कि images एक्स ix एक्स iy एक्स channels

>>> V = tf.Variable() 
>>> print V.get_shape() 

TensorShape([Dimension(-1), Dimension(256), Dimension(256), Dimension(32)]) 

इस उदाहरण ix = 256, iy=256 में

तो, channels=32

पहले टुकड़ा बंद 1 छवि है, और image आयाम को दूर करता है, तो

V = tf.slice(V,(0,0,0,0),(1,-1,-1,-1)) #V[0,...] 
V = tf.reshape(V,(iy,ix,channels)) 

अगला नयी आकृति प्रदान छवि

ix += 4 
iy += 4 
V = tf.image.resize_image_with_crop_or_pad(image, iy, ix) 

चारों ओर शून्य गद्दी के पिक्सल के एक जोड़े को जोड़ने के बाद तो यह है कि 32 के बजाय चैनलों आप 4x8 चैनल है, उन्हें cy=4 और cx=8 फोन की सुविधा देता है।

V = tf.reshape(V,(iy,ix,cy,cx)) 

अब मुश्किल हिस्सा है। tf सी-ऑर्डर, numpy के डिफ़ॉल्ट में परिणाम लौटने लगता है।

वर्तमान आदेश, यदि चपटा, पहला पिक्सेल (cx और cy से अधिक पुनरावृत्ति) के लिए सभी चैनल सूचीबद्ध हैं, (ix incrementing) दूसरे पिक्सेल के चैनल लिस्टिंग से पहले। अगली पंक्ति में बढ़ने से पहले पिक्सल की पंक्तियों (ix) पर जाकर (iy)।

हम ऑर्डर चाहते हैं जो छवियों को ग्रिड में रखे। ताकि आप छवियों (iy) में अगली पंक्ति पर जाने वाले चैनलों की पंक्ति के अंत में हिट करते समय चैनल (cx) की पंक्ति के साथ कदम उठाने से पहले एक छवि (ix) की एक पंक्ति में जाएं, और जब आप चैनल की अगली पंक्ति में बढ़ने वाली छवि में रन आउट या पंक्तियां (cy)। इसलिए:

V = tf.transpose(V,(2,0,3,1)) #cy,iy,cx,ix 

व्यक्तिगत तौर पर मैं np.einsum फैंसी transposes के लिए पसंद करते हैं, पठनीयता के लिए, लेकिन यह tfyet में नहीं है।

newtensor = np.einsum('yxYX->YyXx',oldtensor) 

वैसे भी, अब है कि पिक्सल सही क्रम में हैं, हम सुरक्षित रूप से यह एक 2d टेन्सर में समतल कर सकते हैं:

# image_summary needs 4d input 
V = tf.reshape(V,(1,cy*iy,cx*ix,1)) 

कोशिश कि पर tf.image_summary, आप थोड़ा छवियों का एक ग्रिड मिलना चाहिए।

नीचे सभी चरणों का पालन करने के बाद क्या होता है इसकी एक छवि नीचे दी गई है।

Answer 2

मामले में किसी को Numpy और कल्पना करने के लिए "कूद" चाहते हैं "वहाँ" यहाँ एक उदाहरण Weights और processing result दोनों प्रदर्शित करने के लिए कैसे है। सभी परिवर्तन mdaoust द्वारा पिछली उत्तर पर आधारित हैं।

# to visualize 1st conv layer Weights 
vv1 = sess.run(W_conv1) 

# to visualize 1st conv layer output 
vv2 = sess.run(h_conv1,feed_dict = {img_ph:x, keep_prob: 1.0}) 
vv2 = vv2[0,:,:,:] # in case of bunch out - slice first img 


def vis_conv(v,ix,iy,ch,cy,cx, p = 0) : 
    v = np.reshape(v,(iy,ix,ch)) 
    ix += 2 
    iy += 2 
    npad = ((1,1), (1,1), (0,0)) 
    v = np.pad(v, pad_width=npad, mode='constant', constant_values=p) 
    v = np.reshape(v,(iy,ix,cy,cx)) 
    v = np.transpose(v,(2,0,3,1)) #cy,iy,cx,ix 
    v = np.reshape(v,(cy*iy,cx*ix)) 
    return v 

# W_conv1 - weights 
ix = 5 # data size 
iy = 5 
ch = 32 
cy = 4 # grid from channels: 32 = 4x8 
cx = 8 
v = vis_conv(vv1,ix,iy,ch,cy,cx) 
plt.figure(figsize = (8,8)) 
plt.imshow(v,cmap="Greys_r",interpolation='nearest') 

# h_conv1 - processed image 
ix = 30 # data size 
iy = 30 
v = vis_conv(vv2,ix,iy,ch,cy,cx) 
plt.figure(figsize = (8,8)) 
plt.imshow(v,cmap="Greys_r",interpolation='nearest') 

Answer 3

आप घुमाव के परत सक्रियण छवि इस तरह से प्राप्त करने की कोशिश कर सकते हैं:

h_conv1_features = tf.unpack(h_conv1, axis=3) 
    h_conv1_imgs = tf.expand_dims(tf.concat(1, h_conv1_features_padded), -1) 

इस खड़ी concatenated सभी छवियों के साथ एक खड़ी पट्टी हो जाता है।

h_conv1_features = tf.unpack(h_conv1, axis=3) 
    h_conv1_max = tf.reduce_max(h_conv1) 
    h_conv1_features_padded = map(lambda t: tf.pad(t-h_conv1_max, [[0,0],[0,1],[0,0]])+h_conv1_max, h_conv1_features) 
    h_conv1_imgs = tf.expand_dims(tf.concat(1, h_conv1_features_padded), -1) 

Answer 4

मैं व्यक्तिगत रूप से टाइल करने के लिए एक ही छवि में हर 2 डी फिल्टर का प्रयास करें:

अगर तुम उन्हें गद्देदार (मेरी सफेद लाइन के साथ पैड को Relu सक्रियण के मामले में) चाहते

।

-यदि मैं बहुत गलत के बाद से मैं काफी मुझे पता चला यह depth_to_space समारोह का फायदा उठाने के लिए उपयोगी हो सकता है कि डीएल के लिए नया हूँ, नहीं कर रहा हूँ क्योंकि यह एक 4d टेन्सर लेता है इस _{कर लिए}

[batch, height, width, depth]

और आकार

[batch, height*block_size, width*block_size, depth/(block_size*block_size)]

कहाँ block_size "टाइल" आउटपुट छवि में की संख्या है का उत्पादन पैदा करता है। इसका एकमात्र सीमा यह है कि गहराई ब्लॉक_साइज का वर्ग होना चाहिए, जो एक पूर्णांक है, अन्यथा यह परिणामी छवि को सही ढंग से "भर" नहीं सकता है। एक संभावित समाधान विधि द्वारा स्वीकार किए गए गहराई तक इनपुट टेंसर की गहराई को पैडिंग करने का हो सकता है, लेकिन मैंने यह कोशिश नहीं की है।