สร้างรัฐธรรมนูญและร่วมมือกัน

1. ข้อควรทราบก่อนที่จะเริ่มต้น

ใน Codelab นี้ คุณจะได้รู้เกี่ยวกับการปฏิวัติและสาเหตุที่การปฏิวัติเหล่านี้ทรงพลังมากในคอมพิวเตอร์วิทัศน์

ใน Codelab ที่ผ่านมา คุณได้สร้าง Deep Neural Network (DNN) แบบง่ายสําหรับคอมพิวเตอร์วิทัศน์ของสินค้าแฟชั่น ขั้นตอนนี้ถูกจํากัดเนื่องจากกําหนดให้เสื้อผ้าเป็นสิ่งเดียวในภาพ และต้องอยู่กึ่งกลาง

แน่นอนว่านี่ไม่ใช่สถานการณ์จริง และคุณต้องการให้ DNN ระบุเสื้อผ้าเสื้อผ้ากับวัตถุอื่นๆ ได้ หรือเมื่อไม่ได้วางไว้ด้านหน้าและตรงกลาง หากต้องการดําเนินการนี้ คุณจะต้องใช้การปฏิวัติ

ข้อกำหนดเบื้องต้น

Codelab นี้สร้างขึ้นจากงานที่เสร็จสมบูรณ์ในการผ่อนชําระ 2 ครั้งก่อนหน้า สวัสดี Hello & โลก คอมพิวเตอร์ และแมชชีนเลิร์นนิง และสร้างโมเดลคอมพิวเตอร์วิทัศน์ โปรดดําเนินการ Codelab ดังกล่าวให้เสร็จสิ้นก่อนดําเนินการต่อ

สิ่งที่จะได้เรียนรู้

• การปฏิวัติคืออะไร
• วิธีสร้างการแมปฟีเจอร์
• สระว่ายน้ําคืออะไร

สิ่งที่คุณจะสร้าง

• แผนที่ฟีเจอร์ของรูปภาพ

สิ่งที่ต้องมี

คุณค้นหาโค้ดสําหรับส่วนที่เหลือของ Codelab ได้อยู่ใน Colab

นอกจากนี้คุณยังต้องติดตั้ง TensorFlow และไลบรารีที่ติดตั้งไว้ใน Codelab ก่อนหน้านี้ด้วย

2. การปฏิวัติคืออะไร

การปฏิวัติคือตัวกรองที่เคลื่อนผ่านรูปภาพ ประมวลผล และดึงคุณลักษณะที่สําคัญออก

สมมติว่าคุณมีรูปภาพคนสวมรองเท้าผ้าใบ คุณจะรู้ได้อย่างไรว่ามีรองเท้าผ้าใบอยู่ในรูปภาพ หากต้องการให้โปรแกรมสร้าง "see" รูปภาพเป็นรองเท้าผ้าใบ คุณจะต้องดึงข้อมูลคุณลักษณะที่สําคัญ และเบลอฟีเจอร์ที่จําเป็น ซึ่งเรียกว่าการแมปฟีเจอร์

กระบวนการแมปฟีเจอร์นั้นในทางทฤษฎีนั้นเรียบง่าย คุณจะสแกนทุกพิกเซลในรูปภาพแล้วดูที่พิกเซลใกล้เคียง คูณค่าของพิกเซลเหล่านั้นกับน้ําหนักที่เทียบเท่ากันในตัวกรอง

เช่น

ในกรณีนี้ ระบบจะระบุเมทริกซ์การปฏิวัติ 3x3 หรือเคอร์เนลรูปภาพ

ค่าพิกเซลปัจจุบันคือ 192 คํานวณค่าของพิกเซลใหม่ได้โดยดูที่ค่าเพื่อนบ้าน แล้วคูณค่าที่ระบุในตัวกรอง และทําให้ค่าพิกเซลใหม่เป็นจํานวนเงินสุดท้าย

คราวนี้ก็ถึงเวลาที่จะสํารวจวิธีการทํางานของการปฏิวัติด้วยการสร้างการปฏิวัติพื้นฐานในรูปภาพ 2 มิติสีเทา

คุณจะแสดงข้อมูลดังกล่าวด้วยรูปภาพขาขึ้นจาก SciPy โดยเห็นภาพได้หลายมุมและมุมภาพที่ยอดเยี่ยม

3. เริ่มเขียนโค้ด

เริ่มต้นโดยการนําเข้าไลบรารี Python บางรายการและภาพเพิ่มเติม

import cv2
import numpy as np
from scipy import misc
i = misc.ascent()

ถัดไป ให้ใช้ไลบรารี Pyplot matplotlib เพื่อวาดภาพเพื่อให้คุณเห็นภาพ

import matplotlib.pyplot as plt
plt.grid(False)
plt.gray()
plt.axis('off')
plt.imshow(i)
plt.show()

คุณจะเห็นได้ว่าภาพนี้เป็นบันได มีฟีเจอร์มากมายที่คุณลองแยกได้ เช่น มีเส้นแนวตั้งที่ชัดเจน

รูปภาพจะจัดเก็บเป็นอาร์เรย์ NumPy เพื่อให้เราสร้างรูปภาพที่เปลี่ยนรูปแบบได้โดยคัดลอกอาร์เรย์นั้น ตัวแปร size_x และ size_y จะเก็บขนาดของรูปภาพเพื่อให้วนซ้ําภายหลังได้

i_transformed = np.copy(i)
size_x = i_transformed.shape[0]
size_y = i_transformed.shape[1]

4. สร้างเมทริกซ์การปฏิวัติ

ก่อนอื่นให้สร้างเมทริกซ์การปฏิวัติ (หรือเคอร์เนล) เป็นอาร์เรย์ 3x3

# This filter detects edges nicely
# It creates a filter that only passes through sharp edges and straight lines. 
# Experiment with different values for fun effects.
#filter = [ [0, 1, 0], [1, -4, 1], [0, 1, 0]] 
# A couple more filters to try for fun!
filter = [ [-1, -2, -1], [0, 0, 0], [1, 2, 1]]
#filter = [ [-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]
 # If all the digits in the filter don't add up to 0 or 1, you 
# should probably do a weight to get it to do so
# so, for example, if your weights are 1,1,1 1,2,1 1,1,1
# They add up to 10, so you would set a weight of .1 if you want to normalize them
weight  = 1

ตอนนี้ให้คํานวณพิกเซลเอาต์พุตแล้ว ทําซ้ํารูปภาพ เว้นระยะขอบ 1 พิกเซล แล้วนําเพื่อนบ้านแต่ละรายของพิกเซลปัจจุบันไปคูณกับค่าที่กําหนดไว้ในตัวกรอง

ซึ่งหมายความว่าเพื่อนบ้านคนปัจจุบันของ Pixel ที่อยู่ด้านบนและด้านซ้ายจะคูณด้วยรายการด้านซ้ายบนในตัวกรอง จากนั้นนําผลลัพธ์ที่ได้ไปคูณน้ําหนักและตรวจสอบว่าผลลัพธ์อยู่ในช่วง 0 ถึง 255

สุดท้าย ให้โหลดค่าใหม่ลงในรูปภาพที่แปลงแล้ว

for x in range(1,size_x-1):
  for y in range(1,size_y-1):
      output_pixel = 0.0
      output_pixel = output_pixel + (i[x - 1, y-1] * filter[0][0])
      output_pixel = output_pixel + (i[x, y-1] * filter[0][1])
      output_pixel = output_pixel + (i[x + 1, y-1] * filter[0][2])
      output_pixel = output_pixel + (i[x-1, y] * filter[1][0])
      output_pixel = output_pixel + (i[x, y] * filter[1][1])
      output_pixel = output_pixel + (i[x+1, y] * filter[1][2])
      output_pixel = output_pixel + (i[x-1, y+1] * filter[2][0])
      output_pixel = output_pixel + (i[x, y+1] * filter[2][1])
      output_pixel = output_pixel + (i[x+1, y+1] * filter[2][2])
      output_pixel = output_pixel * weight
      if(output_pixel<0):
        output_pixel=0
      if(output_pixel>255):
        output_pixel=255
      i_transformed[x, y] = output_pixel

5. ตรวจสอบผลลัพธ์

จากนั้นพล็อตรูปภาพเพื่อดูผลจากการส่งฟิลเตอร์

# Plot the image. Note the size of the axes -- they are 512 by 512
plt.gray()
plt.grid(False)
plt.imshow(i_transformed)
#plt.axis('off')
plt.show()   

พิจารณาค่าตัวกรองและผลกระทบต่อรูปภาพต่อไปนี้

การใช้ [-1,0,1,-2,0,2,-1,0,1] จะทําให้คุณมีชุดแนวตั้งที่เข้มมาก:

การใช้ [-1,-2,-1,0,0,0,1,2,1] จะแสดงเส้นแนวนอนดังนี้

สํารวจค่าต่างๆ นอกจากนี้ ให้ลองใช้ตัวกรองที่มีขนาดแตกต่างกัน เช่น 5x5 หรือ 7x7

6. ทําความเข้าใจสระว่ายน้ํา

เมื่อคุณระบุฟีเจอร์สําคัญของรูปภาพได้แล้ว คุณควรทําอะไร คุณใช้การแมปฟีเจอร์ที่ได้เพื่อจัดประเภทรูปภาพอย่างไร

การร่วมกันทํางานคล้ายกับการตรวจหาสิ่งปฏิกูลอย่างมาก เลเยอร์สระว่ายน้ําจะลดปริมาณข้อมูลโดยรวมในภาพ ขณะเดียวกันก็ยังคงมีฟีเจอร์ที่ตรวจพบว่ามีอยู่

การร่วมเก็บข้อมูลมีอยู่หลายประเภท แต่คุณจะใช้ประเภทของการใช้ร่วมกันสูงสุด (สูงสุด) ร่วมกัน

ทําซ้ํารูปภาพและพิจารณาพิกเซลและเพื่อนบ้านข้างขวาไปทางขวา ด้านล่าง และขวาในแต่ละจุด นําไฟล์ขนาดใหญ่ที่สุด (ดังนั้นจึงรวมเข้าด้วยกันได้สูงสุด) และโหลดลงในรูปภาพใหม่ ดังนั้นรูปภาพใหม่จะมีขนาด 1 ใน 4 ของรูปเก่า

7. เขียนโค้ดสําหรับการใช้ร่วมกัน

โค้ดต่อไปนี้จะแสดงกลุ่มแบบรวม (2, 2) เรียกใช้เพื่อดูเอาต์พุต

คุณจะเห็นว่าแม้รูปภาพจะมีขนาดเพียง 1 ใน 4 ของขนาดดั้งเดิม แต่ฟีเจอร์ทั้งหมดยังคงเหมือนเดิม

new_x = int(size_x/2)
new_y = int(size_y/2)
newImage = np.zeros((new_x, new_y))
for x in range(0, size_x, 2):
  for y in range(0, size_y, 2):
    pixels = []
    pixels.append(i_transformed[x, y])
    pixels.append(i_transformed[x+1, y])
    pixels.append(i_transformed[x, y+1])
    pixels.append(i_transformed[x+1, y+1])
    pixels.sort(reverse=True)
    newImage[int(x/2),int(y/2)] = pixels[0]
 
# Plot the image. Note the size of the axes -- now 256 pixels instead of 512
plt.gray()
plt.grid(False)
plt.imshow(newImage)
#plt.axis('off')
plt.show()

จดแกนแกนของพล็อตเรื่องนั้น ตอนนี้รูปภาพมีขนาด 256x256 หนึ่งในสี่ของขนาดเดิม และฟีเจอร์ที่ตรวจพบจะได้รับการปรับปรุงแม้ว่าจะมีข้อมูลของรูปภาพน้อยลงก็ตาม

8. ยินดีด้วย

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