ความแตกต่างระหว่างช่องว่างระหว่าง 'SAME' และ 'VALID' ใน tf.nn.max_pool ของ tenorflow คืออะไร

ความแตกต่างระหว่าง 'เดียวกัน' และ 'ถูกต้อง' padding ในคืออะไรtf.nn.max_poolของtensorflow?

ในความคิดของฉัน 'ถูกต้อง' หมายความว่าจะไม่มีการขยายศูนย์ใด ๆ นอกขอบเมื่อเราทำการรวมกลุ่มสูงสุด

ตามคู่มือคณิตศาสตร์บิดสำหรับการเรียนรู้ลึกมันบอกว่าจะมีช่องว่างในการประกอบการสระว่ายน้ำไม่มีคือเพียงแค่ใช้ 'ถูกต้อง' tensorflowของ แต่ช่องว่างภายใน 'SAME' ของ max pool tensorflowคืออะไร

ฉันจะยกตัวอย่างเพื่อให้ชัดเจนขึ้น:

• x: ภาพอินพุตของรูปร่าง [2, 3], 1 ช่อง
• valid_pad: พูลสูงสุดพร้อมเคอร์เนล 2x2, การเพิ่มส่วนที่ 2 และ VALID
• same_padสระว่ายน้ำสูงสุดกับเคอร์เนล 2x2, ก้าวที่ 2 และ padding เดียวกัน (นี้เป็นคลาสสิกวิธีที่จะไป)

รูปร่างของผลลัพธ์คือ:

• valid_pad: ที่นี่ไม่มีช่องว่างภายในดังนั้นรูปร่างผลลัพธ์คือ [1, 1]
• same_pad: ที่นี่เราตัดภาพให้เป็นรูปร่าง [2, 4] (ด้วย-infแล้วใช้พูลสูงสุด) ดังนั้นรูปร่างผลลัพธ์คือ [1, 2]

x = tf.constant([[1., 2., 3.],
                 [4., 5., 6.]])

x = tf.reshape(x, [1, 2, 3, 1])  # give a shape accepted by tf.nn.max_pool

valid_pad = tf.nn.max_pool(x, [1, 2, 2, 1], [1, 2, 2, 1], padding='VALID')
same_pad = tf.nn.max_pool(x, [1, 2, 2, 1], [1, 2, 2, 1], padding='SAME')

valid_pad.get_shape() == [1, 1, 1, 1]  # valid_pad is [5.]
same_pad.get_shape() == [1, 1, 2, 1]   # same_pad is  [5., 6.]

ถ้าคุณชอบศิลปะ ASCII:

• "VALID" = โดยไม่มีการขยาย:

     inputs:         1  2  3  4  5  6  7  8  9  10 11 (12 13)
                    |________________|                dropped
                                   |_________________|

• "SAME" = ด้วยการเติมศูนย์:

                 pad|                                      |pad
     inputs:      0 |1  2  3  4  5  6  7  8  9  10 11 12 13|0  0
                 |________________|
                                |_________________|
                                               |________________|

ในตัวอย่างนี้:

• ความกว้างของอินพุต = 13
• ความกว้างตัวกรอง = 6
• ก้าวย่าง = 5

หมายเหตุ:

• "VALID" ลดระดับคอลัมน์ขวาสุดเท่านั้น (หรือแถวล่างสุด)
• "SAME" พยายามที่จะ pad ซ้ายและขวาเท่ากัน แต่ถ้าจำนวนคอลัมน์ที่จะเพิ่มแปลกมันจะเพิ่มคอลัมน์พิเศษไปทางขวาเช่นในกรณีนี้ในตัวอย่าง (ตรรกะเดียวกันใช้ในแนวตั้ง: อาจมีแถวพิเศษ ของศูนย์ที่ด้านล่าง)

แก้ไข :

เกี่ยวกับชื่อ:

• ด้วยการ"SAME"แพ็ดดิ้งถ้าคุณใช้การก้าว 1, เอาท์พุทของเลเยอร์จะเหมือนกันมิติเชิงพื้นที่เป็นปัจจัยการผลิตของตน
• ด้วย"VALID"ช่องว่างภายในไม่มีอินพุตช่องว่าง "ทำขึ้น" เลเยอร์ใช้ข้อมูลอินพุตที่ถูกต้องเท่านั้น

เมื่อstrideใดที่ 1 (มากกว่าปกติด้วยการบิดมากกว่าการรวมกำไร) เราสามารถนึกถึงความแตกต่างดังต่อไปนี้:

• "SAME": ขนาดเอาต์พุตเหมือนกันขนาดอินพุต สิ่งนี้ต้องใช้หน้าต่างตัวกรองในการลื่นไถลภายนอกอินพุตแผนที่ดังนั้นจึงจำเป็นต้องมีแผ่น
• "VALID"ตัวกรองการเข้าพักหน้าต่างที่ถูกต้องfilter_size - 1ตำแหน่งภายในแผนที่การป้อนข้อมูลเพื่อการส่งออกหดตัวขนาดโดย ไม่มีการขยายเกิดขึ้น

ตัวอย่างการโน้มน้าวใจ TensorFlowให้ภาพรวมเกี่ยวกับความแตกต่างระหว่างSAMEและVALID:

• สำหรับSAMEช่องว่างภายในนั้นความสูงและความกว้างของเอาต์พุตถูกคำนวณเป็น:

  out_height = ceil(float(in_height) / float(strides[1]))
  out_width  = ceil(float(in_width) / float(strides[2]))

และ

• สำหรับVALIDช่องว่างภายในนั้นความสูงและความกว้างของเอาต์พุตถูกคำนวณเป็น:

  out_height = ceil(float(in_height - filter_height + 1) / float(strides[1]))
  out_width  = ceil(float(in_width - filter_width + 1) / float(strides[2]))

Padding เป็นการดำเนินการเพื่อเพิ่มขนาดของข้อมูลอินพุต ในกรณีของข้อมูล 1 มิติคุณเพียงต่อท้าย / ผนวกอาร์เรย์ด้วยค่าคงที่ใน 2-dim คุณล้อมรอบเมทริกซ์ด้วยค่าคงที่เหล่านี้ ใน n-dim คุณล้อมรอบ n-dim hypercube ของคุณด้วยค่าคงที่ ในกรณีส่วนใหญ่ค่าคงที่นี้เป็นศูนย์และมันถูกเรียกว่า zero-padding

นี่คือตัวอย่างของ zero-padding ที่p=1ใช้กับเมตริกซ์ 2 มิติ:

คุณสามารถใช้การแพ็ดโดยพลการสำหรับเคอร์เนลของคุณ แต่ค่าการแพ็ดบางอย่างถูกใช้บ่อยกว่าค่าอื่น ๆ :

• แพ็ดดิ้งที่ถูกต้อง กรณีที่ง่ายที่สุดหมายถึงไม่มีช่องว่างภายในเลย เพียงแค่ปล่อยให้ข้อมูลของคุณเหมือนเดิม
• padding เดียวกันบางครั้งเรียกว่าครึ่ง padding มันถูกเรียกว่าSAMEเพราะสำหรับ convolution ที่มี stride = 1, (หรือสำหรับการรวมกำไร) มันควรสร้าง output ที่มีขนาดเท่ากันกับ input มันถูกเรียกว่าครึ่งเพราะขนาดเคอร์เนลk
• FULL paddingเป็นpaddingสูงสุดที่ไม่ส่งผลให้เกิดการเปลี่ยนแปลงขององค์ประกอบ สำหรับเคอร์เนลที่มีขนาดรองนี้จะมีค่าเท่ากับkk - 1

ในการใช้ช่องว่างภายในโดยพลการใน TF คุณสามารถใช้ tf.pad()

คำอธิบายด่วน

VALID: ไม่ใช้การขยายใด ๆ เช่นสมมติว่าขนาดทั้งหมดมีผลบังคับใช้เพื่อให้ภาพที่ได้รับการป้อนข้อมูลเต็มโดยตัวกรองและกางเกงที่คุณระบุ

SAME: ใช้ช่องว่างภายในกับอินพุต (หากจำเป็น) เพื่อให้ภาพอินพุตได้รับการคุ้มครองอย่างสมบูรณ์โดยตัวกรองและกางเกงที่คุณระบุ สำหรับ stride 1 สิ่งนี้จะช่วยให้มั่นใจว่าขนาดภาพที่ส่งออกเป็นแบบเดียวกันอินพุต

หมายเหตุ

• สิ่งนี้นำไปใช้กับเลเยอร์ Conv เช่นเดียวกับเลเยอร์พูลสูงสุดในวิธีเดียวกัน
• คำว่า "ถูกต้อง" เป็นบิตของการเรียกชื่อผิดเนื่องจากสิ่งต่าง ๆ ไม่กลายเป็น "ไม่ถูกต้อง" ถ้าคุณดร็อปส่วนหนึ่งของรูปภาพ บางครั้งคุณอาจต้องการที่ สิ่งนี้น่าจะถูกเรียกว่าNO_PADDINGแทน
• คำว่า "เดียวกัน" เป็นตัวเรียกชื่อผิดด้วยเช่นกันเพราะมันเหมาะสมสำหรับการก้าวของ 1 เมื่อขนาดเอาต์พุตเหมือนกับมิติอินพุต สำหรับก้าวย่างของ 2 มิติเอาท์พุทจะเป็นครึ่งหนึ่ง สิ่งนี้น่าจะถูกเรียกAUTO_PADDINGแทน
• ในSAME(เช่นโหมดแผ่นแพดอัตโนมัติ) Tensorflow จะพยายามกระจายการขยายอย่างสม่ำเสมอทั้งซ้ายและขวา
• ในVALID(เช่นไม่มีโหมดการขยาย) Tensorflow จะปล่อยเซลล์ด้านขวาและ / หรือด้านล่างหากตัวกรองและกางเกงของคุณไม่เต็มภาพที่ใส่

ฉันกำลังอ้างอิงคำตอบนี้จากเอกสารอย่างเป็นทางการของ tenorflow https://www.tensorflow.org/api_guides/python/nn#Convolution สำหรับช่องว่าง 'SAME' ความสูงและความกว้างของเอาต์พุตจะถูกคำนวณดังนี้:

out_height = ceil(float(in_height) / float(strides[1]))
out_width  = ceil(float(in_width) / float(strides[2]))

และ padding ที่ด้านบนและด้านซ้ายจะคำนวณเป็น:

pad_along_height = max((out_height - 1) * strides[1] +
                    filter_height - in_height, 0)
pad_along_width = max((out_width - 1) * strides[2] +
                   filter_width - in_width, 0)
pad_top = pad_along_height // 2
pad_bottom = pad_along_height - pad_top
pad_left = pad_along_width // 2
pad_right = pad_along_width - pad_left

สำหรับช่องว่างภายใน 'VALID' จะคำนวณความสูงและความกว้างของเอาต์พุตเป็น:

out_height = ceil(float(in_height - filter_height + 1) / float(strides[1]))
out_width  = ceil(float(in_width - filter_width + 1) / float(strides[2]))

และค่า padding จะเป็นศูนย์เสมอ

มีสามตัวเลือกในการขยาย: ใช้ได้ (ไม่มีการขยาย) เต็ม (หรือครึ่งเดียว) เต็ม คุณสามารถหาคำอธิบาย (ใน Theano) ได้ที่นี่: http://deeplearning.net/software/theano/tutorial/conv_arithmetic.html

• ถูกต้องหรือไม่มีช่องว่างภายใน:

การเติมที่ถูกต้องนั้นไม่มีการเติมเต็มศูนย์ดังนั้นมันจึงครอบคลุมเฉพาะอินพุตที่ถูกต้องเท่านั้นไม่รวมศูนย์ที่สร้างขึ้นด้วยการเลียนแบบ ความยาวของเอาต์พุตคือ ((ความยาวของอินพุต) - (k-1)) สำหรับขนาดเคอร์เนล k ถ้า stride s = 1

• ช่องว่างภายในเดียวกันหรือครึ่ง:

ช่องว่างภายในเดียวกันทำให้ขนาดของเอาต์พุตเหมือนกับขนาดของอินพุตเมื่อ s = 1 ถ้า s = 1 จำนวนของเบาะศูนย์คือ (k-1)

• ช่องว่างภายในเต็ม:

การขยายเต็มรูปแบบหมายถึงเคอร์เนลทำงานเหนืออินพุตทั้งหมดดังนั้นในตอนท้ายเคอร์เนลอาจตอบสนองเพียงอินพุตเดียวและศูนย์อื่น จำนวนของเบาะศูนย์คือ 2 (k-1) ถ้า s = 1 ความยาวของเอาต์พุตคือ ((ความยาวของอินพุต) + (k-1)) ถ้า s = 1

ดังนั้นจำนวนของการขยาย: (ถูกต้อง) <= (เหมือนกัน) <= (เต็ม)

เปิด / ปิดช่องว่างภายใน กำหนดขนาดที่มีประสิทธิภาพของการป้อนข้อมูลของคุณ

VALID:ไม่มีช่องว่างภายใน Convolution ฯลฯ ops จะดำเนินการในสถานที่ที่ "ถูกต้อง" เท่านั้นคือไม่ใกล้กับขอบของเมตริกซ์ของคุณมากเกินไป
ด้วยเคอร์เนลขนาด 3x3 และภาพขนาด 10x10 คุณจะทำการแปลงในพื้นที่ 8x8 ภายในเส้นขอบ

SAME:มีช่องว่างภายใน เมื่อใดก็ตามที่การดำเนินการของคุณอ้างอิงย่านที่คุ้นเคย (ไม่ว่าจะใหญ่เพียงใด) จะมีการตั้งค่าเป็นศูนย์เมื่อย่านนั้นขยายออกไปนอกเมตริกซ์ดั้งเดิม
ด้วยเคอร์เนลขนาด 3x3 และภาพขนาด 10x10 คุณจะทำการแปลงในพื้นที่ 10x10 เต็มรูปแบบ

การเติมช่องว่างที่ถูกต้อง: นี่คือการเติมเต็มศูนย์ หวังว่าจะไม่มีความสับสน

x = tf.constant([[1., 2., 3.], [4., 5., 6.],[ 7., 8., 9.], [ 7., 8., 9.]])
x = tf.reshape(x, [1, 4, 3, 1])
valid_pad = tf.nn.max_pool(x, [1, 2, 2, 1], [1, 2, 2, 1], padding='VALID')
print (valid_pad.get_shape()) # output-->(1, 2, 1, 1)

SAME padding: นี้เป็นชนิดของเรื่องยุ่งยากที่จะเข้าใจในสถานที่แรกเพราะเราต้องพิจารณาเงื่อนไขสองแยกเป็นที่กล่าวถึงในเอกสารอย่างเป็นทางการ

ลองรับอินพุตเป็นเอาต์พุตเป็นpadding as , stride as และขนาดเคอร์เนลเป็น(พิจารณาเพียงมิติเดียวเท่านั้น)

กรณีที่ 01: ::

กรณี 02 ::

มีการคำนวณเช่นนั้นค่าต่ำสุดที่สามารถนำไปใช้สำหรับการขยาย เนื่องจากทราบค่าของค่าจึงสามารถพบได้โดยใช้สูตรนี้นี้

ลองทำตัวอย่างนี้

x = tf.constant([[1., 2., 3.], [4., 5., 6.],[ 7., 8., 9.], [ 7., 8., 9.]])
x = tf.reshape(x, [1, 4, 3, 1])
same_pad = tf.nn.max_pool(x, [1, 2, 2, 1], [1, 2, 2, 1], padding='SAME')
print (same_pad.get_shape()) # --> output (1, 2, 2, 1)

นี่ขนาดของ x คือ (3,4) จากนั้นหากถ่ายในแนวนอน (3):

หากถ่ายในทิศทางแนวตั้ง (4):

หวังว่าสิ่งนี้จะช่วยให้เข้าใจได้จริง เดียวกัน padding ทำงานใน TF

จากคำอธิบายที่นี่และติดตามคำตอบของ Tristan ฉันมักจะใช้ฟังก์ชั่นอย่างรวดเร็วสำหรับการตรวจสอบสติ

# a function to help us stay clean
def getPaddings(pad_along_height,pad_along_width):
    # if even.. easy..
    if pad_along_height%2 == 0:
        pad_top = pad_along_height / 2
        pad_bottom = pad_top
    # if odd
    else:
        pad_top = np.floor( pad_along_height / 2 )
        pad_bottom = np.floor( pad_along_height / 2 ) +1
    # check if width padding is odd or even
    # if even.. easy..
    if pad_along_width%2 == 0:
        pad_left = pad_along_width / 2
        pad_right= pad_left
    # if odd
    else:
        pad_left = np.floor( pad_along_width / 2 )
        pad_right = np.floor( pad_along_width / 2 ) +1
        #
    return pad_top,pad_bottom,pad_left,pad_right

# strides [image index, y, x, depth]
# padding 'SAME' or 'VALID'
# bottom and right sides always get the one additional padded pixel (if padding is odd)
def getOutputDim (inputWidth,inputHeight,filterWidth,filterHeight,strides,padding):
    if padding == 'SAME':
        out_height = np.ceil(float(inputHeight) / float(strides[1]))
        out_width  = np.ceil(float(inputWidth) / float(strides[2]))
        #
        pad_along_height = ((out_height - 1) * strides[1] + filterHeight - inputHeight)
        pad_along_width = ((out_width - 1) * strides[2] + filterWidth - inputWidth)
        #
        # now get padding
        pad_top,pad_bottom,pad_left,pad_right = getPaddings(pad_along_height,pad_along_width)
        #
        print 'output height', out_height
        print 'output width' , out_width
        print 'total pad along height' , pad_along_height
        print 'total pad along width' , pad_along_width
        print 'pad at top' , pad_top
        print 'pad at bottom' ,pad_bottom
        print 'pad at left' , pad_left
        print 'pad at right' ,pad_right

    elif padding == 'VALID':
        out_height = np.ceil(float(inputHeight - filterHeight + 1) / float(strides[1]))
        out_width  = np.ceil(float(inputWidth - filterWidth + 1) / float(strides[2]))
        #
        print 'output height', out_height
        print 'output width' , out_width
        print 'no padding'


# use like so
getOutputDim (80,80,4,4,[1,1,1,1],'SAME')

ในการสรุปการเติมคำว่า 'ที่ถูกต้อง' นั้นไม่ได้หมายความว่าการแพ็ด ขนาดเอาต์พุตของเลเยอร์ convolutional จะลดลงตามขนาดอินพุตและขนาดเคอร์เนล

ในทางตรงข้ามช่องว่างภายใน 'เดียวกัน' หมายถึงการใช้ช่องว่างภายใน เมื่อก้าวย่างถูกตั้งค่าเป็น 1 ขนาดเอาท์พุทของเลเยอร์ Convolutional จะคงไว้เป็นขนาดอินพุตโดยการผนวก '0-border' จำนวนหนึ่งรอบ ๆ ข้อมูลอินพุตเมื่อทำการคำนวณการบิด

หวังว่าคำอธิบายที่เข้าใจง่ายนี้จะช่วยได้

ที่นี่ W และ H คือความกว้างและความสูงของอินพุต F คือขนาดตัวกรอง P คือขนาดของช่องว่างภายใน (เช่นจำนวนแถวหรือคอลัมน์ที่จะเพิ่มขนาด)

สำหรับช่องว่างภายในเดียวกัน:

สำหรับการเติมที่ถูกต้อง:

การตอบสนองที่ยอดเยี่ยมของ YvesgereY ฉันพบว่าการสร้างภาพข้อมูลเป็นประโยชน์อย่างยิ่ง:

การเติมเต็ม ' ถูกต้อง ' เป็นตัวเลขแรก หน้าต่างตัวกรองจะอยู่ภายในภาพ

การขยาย ' เดียวกัน ' เป็นตัวเลขที่สาม เอาต์พุตมีขนาดเท่ากัน

พบว่ามันเกี่ยวกับเรื่องนี้บทความ

Tensorflow 2.0 คำตอบที่เข้ากันได้ : มีคำอธิบายอย่างละเอียดเกี่ยวกับช่องว่างภายใน "ถูกต้อง" และ "เหมือนกัน"

อย่างไรก็ตามฉันจะระบุฟังก์ชันการรวมที่แตกต่างกันและคำสั่งที่เกี่ยวข้องในTensorflow 2.x (>= 2.0)เพื่อประโยชน์ของชุมชน

ฟังก์ชั่นใน 1.x :

tf.nn.max_pool

tf.keras.layers.MaxPool2D

Average Pooling => None in tf.nn, tf.keras.layers.AveragePooling2D

ฟังก์ชั่นใน 2.x :

tf.nn.max_poolหากใช้ใน 2.x และtf.compat.v1.nn.max_pool_v2หรือtf.compat.v2.nn.max_poolหากย้ายจาก 1.x เป็น 2.x

tf.keras.layers.MaxPool2D หากใช้ใน 2.x และ

tf.compat.v1.keras.layers.MaxPool2Dหรือtf.compat.v1.keras.layers.MaxPooling2Dหรือ tf.compat.v2.keras.layers.MaxPool2Dหรือtf.compat.v2.keras.layers.MaxPooling2Dย้ายจาก 1.x เป็น 2.x

Average Pooling => tf.nn.avg_pool2dหรือtf.keras.layers.AveragePooling2Dถ้าใช้ใน TF 2.x และ

tf.compat.v1.nn.avg_pool_v2หรือtf.compat.v2.nn.avg_poolหรือtf.compat.v1.keras.layers.AveragePooling2Dหรือtf.compat.v1.keras.layers.AvgPool2Dหรือtf.compat.v2.keras.layers.AveragePooling2Dหรือtf.compat.v2.keras.layers.AvgPool2Dย้ายจาก 1.x เป็น 2.x

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการย้ายถิ่นจาก Tensorflow 1.x ถึง 2.x โปรดดูคู่มือการย้ายข้อมูลนี้