๋ฐ์ํ
์ด๋ฒ ๊ธ์์๋ ํ๋ฒ Object Detection์ ๋ฐฉ์๋ค์ด ์ด๋ค๊ฒ์ด ์๋์ง ํ๋ฒ ์์๋ณด๊ฒ ์ต๋๋ค.
Sliding Window ๋ฐฉ์
Sliding Window ๋ฐฉ์์ Window๋ฅผ ์ผ์ชฝ ์๋จ๋ถํฐ ์ค๋ฅธ์ชฝ ํ๋จ์ผ๋ก ์ด๋์ํค๋ฉด์ Object๋ฅผ Detection ํ๋ ๋ฐฉ์์ ๋๋ค.
์ฝ๊ฐ ์ด์ดํ, ์ธ๋ฐํ๊ฒ window๋ฅผ ์ด๋์ํค๋ฉด์ ๊ฐ์ฒด ํ์ง๋ฅผ ํ๋ ๋ฐฉ์์ ๋๋ค.
- ์ด๋ฏธ์ง๋ฅผ ์์ ์์ญ์ผ๋ก ๋๋๊ณ , ๊ฐ๊ฐ์ ์์ ์์ญ(์๋์ฐ)์์ ๊ฐ์ฒด๊ฐ ์กด์ฌํ๋์ง๋ฅผ ํ์งํ๋ ๋ฐฉ๋ฒ์ ๋๋ค.
- ์ฅ์ ์ ๋ง์ ์์ญ์ Scan ํ ์ ์๋๊ฒ, Window์ ํํ๋ Image Scale์ ๋ค์ํ๊ฒ ๋ณ๊ฒฝํ ์ ์๋ค๋ ์ ์ ๋๋ค.
- ๋จ์ ์ Object ์๋ ์์ญ๋ ๋ฌด์กฐ๊ฑด ์ฌ๋ผ์ด๋ฉ ํ์ฌ์ผ ํ๋ฉฐ ์ฌ๋ฌ ํํ์ Window์ ์ฌ๋ฌ Scale์ ๊ฐ์ง ์ด๋ฏธ์ง๋ฅผ ์ค์บํด์ ๊ฒ์ถํด์ผ ํ๋ฏ๋ก ์ํ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฌ๊ณ ๊ฒ์ถ ์ฑ๋ฅ์ด ์๋์ ์ผ๋ก ๋ฎ์ต๋๋ค.
- Region Proposal(์์ญ ์ถ์ ) ๊ธฐ๋ฒ์ ๋ฑ์ฅ์ผ๋ก ํ์ฉ๋๋ ๋จ์ด์ก์ง๋ง Object Detection ๋ฐ์ ์ ์ํ ๊ธฐ์ ์ ํ ๋ ์ ๊ณตํ๋ค๋ ์ ์ด ์์ต๋๋ค.
Slicing Window ๋ฐฉ์ ๊ณผ์
์งํ ๋ฐฉ์์ ์๋์ ๊ฐ์ต๋๋ค.
- ์๋์ฐ ํฌ๊ธฐ ์ค์ : ํ์งํ๊ณ ์ ํ๋ ๊ฐ์ฒด์ ํฌ๊ธฐ์ ๋ฐ๋ผ ์๋์ฐ์ ํฌ๊ธฐ๋ฅผ ์ ํฉ๋๋ค. ์ด ์๋์ฐ๋ ์ด๋ฏธ์ง ์ ์ฒด์ ๊ฑธ์ณ ์ด๋ํ ๊ฒ์ ๋๋ค.
- ์๋์ฐ ์ด๋: ์๋์ฐ๋ฅผ ์ด๋ฏธ์ง์ ์์์ ์์๋ถํฐ, ์ผ๋ฐ์ ์ผ๋ก ์ข์ธก ์๋จ์์ ์ฐ์ธก ํ๋จ ๋ฐฉํฅ์ผ๋ก, ์ง์ ๋ ์คํ ํฌ๊ธฐ๋งํผ ์ด๋์ํค๋ฉฐ ๊ฐ ์์น์์ ๊ฐ์ฒด๋ฅผ ํ์งํฉ๋๋ค.
- ๊ฐ์ฒด ํ์ง: ๊ฐ ์๋์ฐ ์์น์์, ์ด๋ฏธ ์ ์๋ ๊ฐ์ฒด ํ์ง ์๊ณ ๋ฆฌ์ฆ(์: Haar feature-based cascade classifiers, SVM ๋ฑ)์ ์ฌ์ฉํ์ฌ ์๋์ฐ ๋ด๋ถ์ ๊ฐ์ฒด๊ฐ ์๋์ง ํ๋จํฉ๋๋ค.
- ๊ฒฐ๊ณผ ์ฒ๋ฆฌ: ๊ฐ ์๋์ฐ์์์ ํ์ง ๊ฒฐ๊ณผ๋ฅผ ์ข ํฉํ์ฌ, ์ต์ข ์ ์ผ๋ก ๊ฐ์ฒด์ ์์น๋ฅผ ๊ฒฐ์ ํฉ๋๋ค. ์ด๋ ์ฌ๋ฌ ์๋์ฐ์์ ์ค๋ณต์ผ๋ก ๊ฐ์ฒด๋ฅผ ํ์งํ์ ์ ์์ผ๋ฏ๋ก, ์ค๋ณต ์ ๊ฑฐ ๊ณผ์ (non-max suppression)์ ๊ฑฐ์ณ ์ต์ข ํ์ง ๊ฒฐ๊ณผ๋ฅผ ์ ๋ฆฌํฉ๋๋ค.
Region Proposal (์์ญ ์ถ์ ) ๋ฐฉ์
"Object๊ฐ ์์ ๋งํ ํ๋ณด ์์ญ์ ์ฐพ์" ์ด๋ฌํ ๊ฐ๋ ์ผ๋ก ์์ญ ์ถ์ ์ ํ๋ ๋ฐฉ์์ผ๋ก Object Detection์ ํฉ๋๋ค.
- ์ด ๋ฐฉ๋ฒ์ ์ด๋ฏธ์ง ๋ด์์ ๊ฐ์ฒด๊ฐ ์กด์ฌํ ๊ฐ๋ฅ์ฑ์ด ๋์ ์์ญ๋ค์ ๋จผ์ ์๋ณํ๊ณ , ๊ทธ ํ์ ์๋ณ๋ ์์ญ๋ค์ ๋์์ผ๋ก ๊ฐ์ฒด ํ์ง๋ฅผ ์ํํ๋ ๋ฐฉ์์ ๋๋ค.
- ์ด๋ฌํ ์ ๊ทผ ๋ฐฉ์์ ๊ณ์ฐ ๋น์ฉ์ ํฌ๊ฒ ์ค์ผ ์ ์์ผ๋ฉฐ, ์ฒ๋ฆฌ ์๋์ ์ ํ๋๋ฅผ ๋์์ ํฅ์์ํฌ ์ ์์ต๋๋ค.
Selective Search – Region Proposal์ ๋ํ ๋ฐฉ๋ฒ
Seltective Search๋ ์ด๋ฏธ์ง ๋ด์์ ๋์ ์ ํ๋๋ก ๊ฐ์ฒด๊ฐ ์์นํ ๊ฐ๋ฅ์ฑ์ด ์๋ ์์ญ์ ์ ์ํ๊ฒ ์ถ์ ํ๋ ๋ฐ ์ค์ ์ ๋ก๋๋ค.
- Selective Search๋ ์ด๋ฏธ์ง ์ธ๋ถํ(image segmentation) ๊ธฐ์ ์ ๊ธฐ๋ฐ์ผ๋ก ํฉ๋๋ค.
- ๋น ๋ฅธ Detection๊ณผ ๋์ Recall ์์ธก ์ฑ๋ฅ์ ๋์์ ๋ง์กฑํ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค.
- ์ปฌ๋ฌ, ๋ฌด๋ฌ(Texture), ํฌ๊ธฐ(Size), ํํ(Shape)์ ๋ฐ๋ผ ์ ์ฌํ Region์ ๊ณ์ธต์ ๊ทธ๋ฃนํ ๋ฐฉ๋ฒ์ผ๋ก ๊ณ์ฐํฉ๋๋ค.
- Selective Search๋ ์ต์ด์๋ Pixel Intensity๊ธฐ๋ฐํ graph-based segment ๊ธฐ๋ฒ์ ๋ฐ๋ผ Over Segmentation์ ์ํํ์ต๋๋ค.
- (๊ฐ๊ฐ์ object๋ค์ด 1๊ฐ์ ๊ฐ๋ณ ์์ญ์ ๋ด๊ธธ ์ ์๋๋ก ๋ง์ ์ด๊ธฐ ์์ญ์ ์์ฑ by Felzenszwalb and Huttenlocher 2004)
- ํน์ง์, ์๋ณธ ์ด๋ฏธ์ง์์ Segmentation์ ์ ์ฉํ ๋ ๊ฐ ํฝ์ ๊ฐ์ ๊ธฐ๋ฐํด์ Object๊ฐ ๋ ์ ์๋ ๊ท์น์ ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฉํฉ๋๋ค.
- ๊ทธ ํ, image๋ค์ ํน์ ์์ญ์ Segmentation์ ์ ์ฉํฉ๋๋ค. (pixel by pixel)
Selective Search์ ์ํ Process
์ด๋ ํ ๊ณผ์ ์ผ๋ก Selective Search์ ์ํ Process๊ฐ ์คํ๋๋์ง ํ๋ฒ ์์๋ณด๊ฒ ์ต๋๋ค.
- ๊ฐ๋ณ Segment๋ ๋ชจ๋ ๋ถ๋ถ๋ค์ Bounding box๋ก ๋ง๋ค์ด์ Region Proposal ๋ฆฌ์คํธ๋ก ์ถ๊ฐํฉ๋๋ค.
- ์ปฌ๋ฌ, ๋ฌด๋ฌ(Texture), ํฌ๊ธฐ(Size), ํํ(Shape)์ ๋ฐ๋ผ ์ ์ฌ๋๊ฐ ๋น์ทํ Segment๋ค์ ๊ทธ๋ฃนํํฉ๋๋ค.
- ๋ค์ 1๋ฒ Step Region Proposal ๋ฆฌ์คํธ ์ถ๊ฐ, 2๋ฒ Step ์ ์ฌ๋๊ฐ ๋น์ทํ Segment๋ค ๊ทธ๋ฃนํ์ ๊ณ์ ๋ฐ๋ณต ํ๋ฉด์ Region Proposal์ ์ํํฉ๋๋ค.
selective search๋ฅผ ์ด์ฉํ์ฌ Object Detection์ ์ํ Region Proposal ์์ญ์ ๋์ถ
๊ทธ๋ฌ๋ฉด ํ๋ฒ ์ฝ๋๋ฅผ ๋๋ ค์ ์์ต์ ํ๋ฒ ๋์ถ์ ๋ณด๊ฒ ์ต๋๋ค.
- ์ผ๋จ ์ฌ์ง์ ํ์ธํ๊ธฐ ์ํด์ Matplotlib์ผ๋ก ์๊ฐํ๋ฅผ ํด๋ณด๊ฒ ์ต๋๋ค.
import selectivesearch
import cv2
import matplotlib.pyplot as plt
%matplotlib inline
### ์ค๋๋ฆฌํต๋ฒ ์ด๋ฏธ์ง๋ฅผ cv2๋ก ๋ก๋ํ๊ณ matplotlib์ผ๋ก ์๊ฐํ
img = cv2.imread('/content/drive/MyDrive/แแ
ตแธแ
แ
ฅแแ
ตแผ แแ
ฅแทแแ
ฒแแ
ฅ แแ
ตแแ
ฅแซ แแ
กแแ
ตแแ
ณ/Deep_learning computer Vision Guide/data/image/audrey01.jpg')
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
print('img shape:', img.shape)
plt.figure(figsize=(8, 8))
plt.imshow(img_rgb)
plt.show()
# selective_search ํจ์๋ฅผ ์ด์ฉํ์ฌ img_rgb ์ด๋ฏธ์ง์์ Region Proposal์ ์์ฑํฉ๋๋ค.
# scale ๋งค๊ฐ๋ณ์๋ ์ด๋ฏธ์ง ์ธ๋ถํ ์ ์ธ๊ทธ๋จผํธ์ ํฌ๊ธฐ๋ฅผ ์กฐ์ ํ๋ฉฐ, min_size๋ ์์ฑ๋๋ ์ต์ ์์ญ์ ํฌ๊ธฐ๋ฅผ ์ง์ ํฉ๋๋ค.
_, regions = selectivesearch.selective_search(img_rgb, scale=100, min_size=2000)
# regions์ ํ์
๊ณผ ๊ธธ์ด๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
print(type(regions), len(regions))
๋ฐํ๋ Region Proposal(ํ๋ณด ์์ญ)์ ๋ํ ์ ๋ณด ๋ณด๊ธฐ.
๋ฐํ๋ regions ๋ณ์๋ ๋ฆฌ์คํธ ํ์ ์ผ๋ก ์ธ๋ถ ์์๋ก ๋์ ๋๋ฆฌ๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค. ์ด๊ฑด ๊ฐ๋ณ ๋์ ๋๋ฆฌ๋ด KEY๊ฐ์ ์๋ฏธํฉ๋๋ค.
- rect ํค๊ฐ์ x,y ์์ ์ขํ์ ๋๋น, ๋์ด ๊ฐ์ ๊ฐ์ง๋ฉฐ ์ด ๊ฐ์ด Detected Object ํ๋ณด๋ฅผ ๋ํ๋ด๋ Bounding box ์ ๋๋ค.
- size๋ Bounding box์ ํฌ๊ธฐ์ ๋๋ค.
- labels๋ ํด๋น rect๋ก ์ง์ ๋ Bounding Box๋ด์ ์๋ ์ค๋ธ์ ํธ๋ค์ ๊ณ ์ ID๋ฅผ ์๋ฏธํฉ๋๋ค.
- ์๋๋ก ๋ด๋ ค๊ฐ ์๋ก ๋๋น์ ๋์ด ๊ฐ์ด ํฐ Bounding box์ด๋ฉฐ ํ๋์ Bounding box์ ์ฌ๋ฌ๊ฐ์ ์ค๋ธ์ ํธ๊ฐ ์์ ํ๋ฅ ์ด ์ปค์ง๋๋ค.
[{'rect': (0, 0, 107, 167), 'size': 11166, 'labels': [0.0]},
- Regions๋ฅผ ์ถ๋ ฅํ๋ฉด ์์ ์ฒ๋ผ ๊ฒฐ๊ณผ๊ฐ ๋์ต๋๋ค.
- ์๋ฏธํ๋๊ฑด 'rect': (0, 0, 107, 167) ์์ (0, 0)์ Bounding Box์ ์ข์๋จ ์ขํ, 107์ Width(๋๋น), 167์ Height(๋์ด)๋ฅผ ์๋ฏธํฉ๋๋ค.
# rect์ ๋ณด๋ง ์ถ๋ ฅํด์ ๋ณด๊ธฐ
cand_rects = [cand['rect'] for cand in regions]
print(cand_rects)
- ๊ทธ๋ฌ๋ฉด ํ๋ฒ Bounding Box๋ฅผ ํ๋ฒ ์๊ฐํ๋ฅผ ํด์ ๋ณด๊ฒ ์ต๋๋ค.
# opencv์ rectangle()์ ์ด์ฉํ์ฌ ์๊ฐํ
# rectangle()์ ์ด๋ฏธ์ง์ ์ข์๋จ ์ขํ, ์ฐํ๋จ ์ขํ, box์ปฌ๋ฌ์, ๋๊ป๋ฑ์ ์ธ์๋ก ์
๋ ฅํ๋ฉด ์๋ณธ ์ด๋ฏธ์ง์ box๋ฅผ ๊ทธ๋ ค์ค.
# RGB ์์์ผ๋ก ๋
น์์ ์ ์.
green_rgb = (125, 255, 51)
# ์๋ณธ ์ด๋ฏธ์ง์ ๋ณต์ฌ๋ณธ์ ์์ฑ. ๋ณต์ฌ๋ณธ์ ์ฌ๊ฐํ์ ๊ทธ๋ ค ์๋ณธ ์ด๋ฏธ์ง๋ฅผ ๋ณ๊ฒฝํ์ง ์.
img_rgb_copy = img_rgb.copy()
# cand_rects ๋ฆฌ์คํธ์ ๊ฐ ์ฌ๊ฐํ ์์ญ(rect)์ ๋ํด ๋ฐ๋ณต ์ํ.
for rect in cand_rects:
# ์ข์๋จ ์ขํ๋ฅผ ์ถ์ถ.
left = rect[0]
top = rect[1]
# rect[2]์ rect[3]๋ ๊ฐ๊ฐ ๋๋น์ ๋์ด์ด๋ฏ๋ก, ์ฐํ๋จ ์ขํ๋ฅผ ๊ณ์ฐํ๊ธฐ ์ํด ์ข์๋จ ์ขํ์ ๋ํฉ๋๋ค.
right = left + rect[2]
bottom = top + rect[3]
# cv2.rectangle ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์ด๋ฏธ์ง์ ์ฌ๊ฐํ์ ๊ทธ๋ฆฝ๋๋ค.
# ์ข์๋จ ์ขํ (left, top)๊ณผ ์ฐํ๋จ ์ขํ (right, bottom)๋ฅผ ์ฌ์ฉํ๋ฉฐ, ์ฌ๊ฐํ์ ์์์ ๋
น์, ๋๊ป๋ 2๋ก ์ค์ ๋ฉ๋๋ค.
img_rgb_copy = cv2.rectangle(img_rgb_copy, (left, top), (right, bottom), color=green_rgb, thickness=2)
plt.figure(figsize=(8, 8))
plt.imshow(img_rgb_copy)
plt.show()
Bounding Box์ ํฌ๊ธฐ๊ฐ ํฐ ํ๋ณด๋ง ์ถ์ถ
4๋จ๊ณ๋ก ๋๋ฉ๋๋ค. ์์ญํํฐ๋ง, ์ด๊ธฐ ์ค์ , Bounding Box ๊ทธ๋ฆฌ๊ธฐ, ์ด๋ฏธ์ง ์๊ฐํ๋ก ๋๋ฉ๋๋ค.
# regions์์ ๊ฐ ํ๋ณด ์์ญ์ ์ฌ์ด์ฆ๊ฐ 10,000 ์ด์์ธ ๊ฒ๋ง์ ์ ํํ์ฌ cand_rects ๋ฆฌ์คํธ๋ฅผ ์์ฑํฉ๋๋ค.
cand_rects = [cand['rect'] for cand in regions if cand['size'] > 10000]
# ์ฌ๊ฐํ์ ์์์ผ๋ก ๋
น์์ ์ ์ํฉ๋๋ค.
green_rgb = (125, 255, 51)
# ์๋ณธ ์ด๋ฏธ์ง์ ๋ณต์ฌ๋ณธ์ ์์ฑํฉ๋๋ค. ์์
์ค ์๋ณธ ์ด๋ฏธ์ง๋ ๋ณ๊ฒฝ๋์ง ์์ต๋๋ค.
img_rgb_copy = img_rgb.copy()
# ํํฐ๋ง๋ ์ฌ๊ฐํ ์์ญ๋ค์ ๋ฐ๋ณตํ๋ฉฐ ์ด๋ฏธ์ง์ ์ฌ๊ฐํ์ ๊ทธ๋ฆฝ๋๋ค.
for rect in cand_rects:
# ์ฌ๊ฐํ์ ์ข์๋จ ์ขํ๋ฅผ ์ถ์ถํฉ๋๋ค.
left = rect[0]
top = rect[1]
# ๋๋น์ ๋์ด๋ฅผ ์ฌ์ฉํ์ฌ ์ฌ๊ฐํ์ ์ฐํ๋จ ์ขํ๋ฅผ ๊ณ์ฐํฉ๋๋ค.
right = left + rect[2]
bottom = top + rect[3]
# OpenCV์ rectangle ํจ์๋ฅผ ์ด์ฉํ์ฌ ์ด๋ฏธ์ง ๋ณต์ฌ๋ณธ์ ์ฌ๊ฐํ์ ๊ทธ๋ฆฝ๋๋ค.
img_rgb_copy = cv2.rectangle(img_rgb_copy, (left, top), (right, bottom), color=green_rgb, thickness=2)
# matplotlib ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ์ฌ ์ด๋ฏธ์ง๋ฅผ ์๊ฐํํฉ๋๋ค.
plt.figure(figsize=(8, 8))
plt.imshow(img_rgb_copy)
plt.show()
- ์ด๋ ๊ฒ ๊ฒฐ๊ณผ๋ก ๋ณด์ด๋ฏ์ด, ์์ ๊ฒฐ๊ณผ์๋ ๋ค๋ฅด๊ฒ ํฐ Bounding Box๋ง ์ถ์ถ ํ๋๊ฒ์ ๋ณผ ์ ์์ต๋๋ค.
Object Detection ์ฑ๋ฅ ํ๊ฐ Metric - IoU: Intersection over Union
IoU๋ ์์ธก๋ ๊ฒฝ๊ณ ์์(Bounding Box)์ ์ค์ ๊ฐ์ฒด์ ๊ฒฝ๊ณ ์์ ๊ฐ์ ์ค๋ฒ๋ฉ์ ์ธก์ ํ๋ ๋ฐฉ๋ฒ์ผ๋ก,
๋ชจ๋ธ์ด ์์ธกํ ๊ฒฐ๊ณผ์ ์ค์ธก(Ground Truth) Box๊ฐ ์ผ๋ง๋ ์ ํํ๊ฒ ๊ฒน์น๋๊ฐ๋ฅผ ๋ํ๋ด๋ ์งํ์ ๋๋ค.
- IoU์ ๊ณ์ฐ์ ๋ค์๊ณผ ๊ฐ์ด ์งํ๋ฉ๋๋ค.
IoU = Area of Union / Area of Overlapโ
- ์ฌ๊ธฐ์, Area of Overlap์ ์์ธก๋ ์์์ ์ค์ ์์๊ฐ ๊ฒน์น๋ ์์ญ์ ๋ฉด์ ์ ๋๋ค.
- Area of Union์ ์์ธก๋ ์์์ ์ค์ ์์๊ฐ ํฉ์ณ์ง ์์ญ์ ๋ฉด์ ์
๋๋ค.
- ์ฆ ๋ ์์์ ๋ฉด์ ํฉ์์ ๊ฒน์น๋ ๋ถ๋ถ์ ๋ฉด์ ์ ๋บ ๊ฐ์ ๋๋ค.
- IoU์ ๊ฐ ํด์
- 1.0: ์๋ฒฝํ ๊ฒน์นจ. ์์ธก๋ ์์์ ์ค์ ์์๊ฐ ์ ํํ ์ผ์นํฉ๋๋ค.
- 0.0: ์ ํ ๊ฒน์น์ง ์์. ์์ธก๋ ์์์ ์ค์ ์์ ์ฌ์ด์ ๊ฒน์น๋ ์์ญ์ด ์์ต๋๋ค.
- ์ผ๋ฐ์ ์ผ๋ก, IoU์ ๊ฐ์ด ๋์์๋ก ๊ฐ์ฒด ํ์ง ๋ชจ๋ธ์ ์ฑ๋ฅ์ด ์ข๋ค๊ณ ํ๊ฐํฉ๋๋ค.
- ๋ง์ฝ IoU ๊ฐ์ด 0.5 ์ด์์ธ ๊ฒฝ์ฐ์ ๊ฐ์ฒด ํ์ง๋ฅผ ์ฑ๊ณต์ ์ผ๋ก ํ ๊ฒ์ผ๋ก ๊ฐ์ฃผํฉ๋๋ค.
- ๊ทธ๋ฌ๋ฉด ํ๋ฒ IoU๋ฅผ ๊ตฌํด๋ณด๊ฒ ์ต๋๋ค.
IoU ๊ตฌํ๊ธฐ
์ ๋ ฅ์ธ์๋ก ํ๋ณด Box์ ์ค์ Box๋ฅผ ๋ฐ์์ IoU๋ฅผ ๊ณ์ฐ ํ๋ ํจ์๋ฅผ ๋ง๋ค์ด์ ๊ณ์ฐ์ ํด๋ณด๊ฒ ์ต๋๋ค.
- IoU ๊ณ์ฐ ํจ์ ์ฝ๋
import numpy as np
def compute_iou(cand_box, gt_box):
# ๊ฐ ๊ฒฝ๊ณ ์์์ ์ขํ๋ฅผ ๋น๊ตํ์ฌ ๊ฒน์น๋ ์์ญ์ ์ข์๋จ๊ณผ ์ฐํ๋จ ์ขํ๋ฅผ ๊ณ์ฐํฉ๋๋ค.
# np.maximum๊ณผ np.minimum์ ์ฌ์ฉํ์ฌ ๊ฐ ์ขํ์ ์ต๋ ๋ฐ ์ต์๊ฐ์ ์ฐพ์ ๊ฒน์น๋ ์์ญ์ ์ ์ํฉ๋๋ค.
x1 = np.maximum(cand_box[0], gt_box[0])
y1 = np.maximum(cand_box[1], gt_box[1])
x2 = np.minimum(cand_box[2], gt_box[2])
y2 = np.minimum(cand_box[3], gt_box[3])
# ๊ฒน์น๋ ์์ญ์ ๋๋น์ ๋์ด๋ฅผ ๊ณ์ฐํฉ๋๋ค. ๊ฐ์ด ์์์ธ ๊ฒฝ์ฐ 0์ผ๋ก ์ค์ ํ์ฌ ๊ฒน์น๋ ์์ญ์ด ์์์ ํ์ํฉ๋๋ค.
intersection = np.maximum(x2 - x1, 0) * np.maximum(y2 - y1, 0)
# ํ๋ณด ์์(cand_box)์ ์ค์ ์์(gt_box)์ ๋๋น์ ๋์ด๋ฅผ ๊ณ์ฐํ์ฌ ๊ฐ ์์์ ๋ฉด์ ์ ๊ตฌํฉ๋๋ค.
cand_box_area = (cand_box[2] - cand_box[0]) * (cand_box[3] - cand_box[1])
gt_box_area = (gt_box[2] - gt_box[0]) * (gt_box[3] - gt_box[1])
# ํฉ์งํฉ ์์ญ์ ๊ณ์ฐํฉ๋๋ค: ๋ ์์์ ๋ฉด์ ํฉ์์ ๊ฒน์น๋ ์์ญ์ ๋ฉด์ ์ ๋นผ์ค๋๋ค.
union = cand_box_area + gt_box_area - intersection
# IoU๋ฅผ ๊ณ์ฐํฉ๋๋ค. ๊ฒน์น๋ ์์ญ์ ํฉ์งํฉ์ผ๋ก ๋๋ ๊ฐ์
๋๋ค.
iou = intersection / union
return iou
- ์ฌ์ง์ ๋ถ๋ฌ์์ ์๊ฐํ ํ๋ ์ฝ๋
import cv2
import matplotlib.pyplot as plt
%matplotlib inline
# ์ค์ box(Ground Truth)์ ์ขํ๋ฅผ ์๋์ ๊ฐ๋ค๊ณ ๊ฐ์ .
gt_box = [60, 15, 320, 420]
img = cv2.imread('/content/drive/MyDrive/แแ
ตแธแ
แ
ฅแแ
ตแผ แแ
ฅแทแแ
ฒแแ
ฅ แแ
ตแแ
ฅแซ แแ
กแแ
ตแแ
ณ/Deep_learning computer Vision Guide/data/image/audrey01.jpg')
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
red = (255, 0 , 0)
img_rgb = cv2.rectangle(img_rgb, (gt_box[0], gt_box[1]), (gt_box[2], gt_box[3]), color=red, thickness=2)
plt.figure(figsize=(8, 8))
plt.imshow(img_rgb)
plt.show()
- Selective Search Code
# selective_search ํจ์๋ฅผ ์ด์ฉํ์ฌ img_rgb ์ด๋ฏธ์ง์์ Region Proposal์ ์์ฑํฉ๋๋ค.
# scale ๋งค๊ฐ๋ณ์๋ ์ด๋ฏธ์ง ์ธ๋ถํ ์ ์ธ๊ทธ๋จผํธ์ ํฌ๊ธฐ๋ฅผ ์กฐ์ ํ๋ฉฐ, min_size๋ ์์ฑ๋๋ ์ต์ ์์ญ์ ํฌ๊ธฐ๋ฅผ ์ง์ ํฉ๋๋ค.
_, regions = selectivesearch.selective_search(img_rgb, scale=100, min_size=2000)
# regions์ ํ์
๊ณผ ๊ธธ์ด๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
print(type(regions), len(regions))
- regions์์ ๋ฐ์ ํ๋ณด ์์ญ(cand_rects)์ ๋ํด ๊ฐ๊ฐ์ cand_box๋ฅผ ์กฐ์ ํ๊ณ ,
- ์ค์ ๊ฐ์ฒด ์์ญ์ธ gt_box์์ IoU(Intersection over Union)๋ฅผ ๊ณ์ฐํ์ฌ ์ถ๋ ฅํ๋ ๊ณผ์ ์ ๋ด์ ์ฝ๋์ ๋๋ค.
# regions๋ก๋ถํฐ ๊ฐ ํ๋ณด์ ์ฌ๊ฐํ ๊ฒฝ๊ณ('rect')๋ฅผ ์ถ์ถํ์ฌ cand_rects ๋ฆฌ์คํธ์ ์ ์ฅํฉ๋๋ค.
cand_rects = [cand['rect'] for cand in regions]
# cand_rects ๋ฆฌ์คํธ๋ฅผ ์ํํ๋ฉฐ ๊ฐ ํ๋ณด ์์์ ์ธ๋ฑ์ค์ ๊ฐ์ ๊ฐ์ ธ์ต๋๋ค.
for index, cand_box in enumerate(cand_rects):
# cand_box๋ ํํ์ด๋ฏ๋ก ๋ฆฌ์คํธ๋ก ๋ณํํ์ฌ ์์ ๊ฐ๋ฅํ๊ฒ ํฉ๋๋ค.
cand_box = list(cand_box)
# cand_box์ ๋๋น์ ๋์ด ๊ฐ์ ์ขํ ๊ฐ์ผ๋ก ๋ณํํฉ๋๋ค.
# cand_box[2]์ cand_box[3]๋ ์๋ ๋๋น์ ๋์ด์ด๋ฏ๋ก ์ด๋ฅผ ์ข์๋จ ์ขํ์ ๋ํ์ฌ ์ฐํ๋จ ์ขํ๋ฅผ ๊ตฌํฉ๋๋ค.
cand_box[2] += cand_box[0]
cand_box[3] += cand_box[1]
# ์์ ๋ cand_box์ ์ฃผ์ด์ง gt_box(์ค์ ๊ฐ์ฒด ์์ญ)์ IoU๋ฅผ ๊ณ์ฐํฉ๋๋ค.
iou = compute_iou(cand_box, gt_box)
# ๊ฐ ํ๋ณด ์์์ ์ธ๋ฑ์ค์ ๊ณ์ฐ๋ IoU ๊ฐ์ ์ถ๋ ฅํฉ๋๋ค.
print('index:', index, "iou:", iou)
- ์ด ์ฝ๋๋ฅผ ์คํํ๋ฉด ์๋์ฒ๋ผ ๊ฐ index ๋ณ๋ก IoU ๊ฐ์ด ๋์ต๋๋ค.
index: 0 iou: 0.0
index: 1 iou: 0.0713319505816575
index: 2 iou: 0.1134453781512605
index: 3 iou: 0.9874899187876287
index: 4 iou: 0.9748907882241216
index: 5 iou: 0.09851851851851852
index: 6 iou: 0.04228869895536562
index: 7 iou: 0.15042735042735042
index: 8 iou: 0.14541310541310543
index: 9 iou: 0.10112060778727446
index: 10 iou: 0.1194681861348528
index: 11 iou: 0.14017094017094017
- ์ด ์ฝ๋๋ ์ฃผ์ด์ง regions ๋ฐ์ดํฐ์์ ํน์ ์กฐ๊ฑด(size > 5000)์ ๋ง์กฑํ๋ ํ๋ณด ์์ญ๋ค์ ํํฐ๋งํ๊ณ , ์ด๋ค์ ์ ๋ ฌํ๋ ๊ณผ์ ์ ์ํํ๋ ์ฝ๋์ ๋๋ค.
# regions ๋ฆฌ์คํธ์์ ๊ฐ ํ๋ณด ์์ญ์ 'size' ์์ฑ์ด 5000 ์ด๊ณผ์ธ ํ๋ณด๋ค๋ง์ ์ ํํ์ฌ cand_rects ๋ฆฌ์คํธ์ ์ ์ฅํฉ๋๋ค.
cand_rects = [cand['rect'] for cand in regions if cand['size'] > 5000]
# cand_rects ๋ฆฌ์คํธ๋ฅผ ์ฌ์ ์์ผ๋ก ์ ๋ ฌํฉ๋๋ค.
# ์ฌ๊ธฐ์ ๊ฐ ํ๋ณด ์์ญ(rect)์ (x1, y1, width, height)์ ํํ ํํ๋ก ๊ฐ์ ๋๋ฉฐ, Python์ ๊ธฐ๋ณธ ์ ๋ ฌ์ ํํ์ ์ฒซ ๋ฒ์งธ ์์๋ถํฐ ๋น๊ตํฉ๋๋ค.
# ๋ฐ๋ผ์ x1 ๊ฐ์ ๋ฐ๋ผ ์ ๋ ฌ๋๋ฉฐ, ๊ฐ์ x1 ๊ฐ์ ๊ฐ์ง ์์๋ y1 ๊ฐ์ ๋ฐ๋ผ ์ ๋ ฌ๋ฉ๋๋ค.
cand_rects.sort()
# ์ ๋ ฌ๋ cand_rects ๋ฆฌ์คํธ๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
cand_rects
- ๊ทธ๋ฌ๋ฉด ์ด์ , Object Detection์ ์ํด ์ด๋ฏธ์ง์์ ํน์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ํ๋ณด ์์ญ๋ค์ ์ถ์ถํ๊ณ , ์ด๋ค ์์ญ์ ๋ํ IoU (Intersection over Union) ๊ฐ์ ๊ณ์ฐํ์ฌ ์ด๋ฏธ์ง์ ์๊ฐํํ๋ ๊ณผ์ ์ ํด๋ณด๊ฒ ์ต๋๋ค.
img = cv2.imread('/content/drive/MyDrive/๋ฅ๋ฌ๋ ์ปดํจํฐ ๋น์ ๊ฐ์ด๋/Deep_learning computer Vision Guide/data/image/audrey01.jpg')
# BGR ์์ ํ์์ ์ด๋ฏธ์ง๋ฅผ RGB ์์ ํ์์ผ๋ก ๋ณํํฉ๋๋ค.
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# ์ด๋ฏธ์ง์ ํํ(ํฌ๊ธฐ, ์ฑ๋)๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
print('img shape:', img.shape)
# gt_box๋ฅผ ์ ์ํ๊ณ ์ค์ ๊ฐ์ฒด์ ๊ฒฝ๊ณ ์์๋ฅผ ๊ทธ๋ฆฝ๋๋ค. ์ฌ๊ธฐ์ 'red'๊ฐ ์ ์๋์ง ์์์ผ๋ฏ๋ก ์ ์ ํ ์์ ๊ฐ์ผ๋ก ๋์ฒดํด์ผ ํฉ๋๋ค.
green_rgb = (125, 255, 51)
gt_box = [60, 15, 320, 420]
img_rgb = cv2.rectangle(img_rgb, (gt_box[0], gt_box[1]), (gt_box[2], gt_box[3]), color=green_rgb, thickness=2)
# 'regions'์์ ํน์ ํฌ๊ธฐ ์ด์์ ํ๋ณด ์์๋ง ์ ํํฉ๋๋ค.
cand_rects = [cand['rect'] for cand in regions if cand['size'] > 3000]
# ํ๋ณด ์์๋ฅผ ์ํํ๋ฉด์ ๊ฐ ์์์ ๋ํ IoU๋ฅผ ๊ณ์ฐํ๊ณ , ์กฐ๊ฑด์ ๋ง๋ ๊ฒฝ์ฐ์๋ง ํ
์คํธ์ ์์๋ฅผ ๊ทธ๋ฆฝ๋๋ค.
for index, cand_box in enumerate(cand_rects):
# ํ๋ณด ์์์ ํฌ๊ธฐ๋ฅผ ์กฐ์ ํฉ๋๋ค.
cand_box = list(cand_box)
cand_box[2] += cand_box[0]
cand_box[3] += cand_box[1]
# IoU๋ฅผ ๊ณ์ฐํฉ๋๋ค.
iou = compute_iou(cand_box, gt_box)
# IoU๊ฐ 0.5 ์ด์์ธ ๊ฒฝ์ฐ, ์์๋ฅผ ๊ทธ๋ฆฌ๊ณ ์ธ๋ฑ์ค์ IoU ๊ฐ์ ํ
์คํธ๋ก ์ถ๊ฐํฉ๋๋ค.
if iou > 0.5:
print('index:', index, "iou:", iou, 'rectangle:', (cand_box[0], cand_box[1], cand_box[2], cand_box[3]))
cv2.rectangle(img_rgb, (cand_box[0], cand_box[1]), (cand_box[2], cand_box[3]), color=green_rgb, thickness=1)
text = "{}: {:.2f}".format(index, iou)
cv2.putText(img_rgb, text, (cand_box[0] + 100, cand_box[1] + 10), cv2.FONT_HERSHEY_SIMPLEX, 0.4, color=green_rgb, thickness=1)
plt.figure(figsize=(12, 12))
plt.imshow(img_rgb)
plt.show()
NMS (Non Max Supression)
NMS (Non-Max Suppression, ๋น์ต๋ ์ต์ )๋ ์ปดํจํฐ ๋น์ , ํนํ ๊ฐ์ฒด ํ์ง์์ ์ค๋ณต ๊ฒ์ถ๋ ๊ฐ์ฒด๋ค์ ์ ์ ํ๋ ๊ณผ์ ์์ ์ฌ์ฉ๋๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค.
- ๊ฐ์ฒด ํ์ง ๊ณผ์ ์์ ํ๋์ ๊ฐ์ฒด์ ๋ํด ์ฌ๋ฌ ๊ฐ์ Bounding box๊ฐ ์์ฑ๋ ์ ์์ต๋๋ค.
- Object Detection ์๊ณ ๋ฆฌ์ฆ์ Object ๊ฐ์์ ๋งํ ์์น์ ๋ง์ Detection์ ์ํํ๋ ๊ฒฝํฅ์ด ๊ฐํฉ๋๋ค.
- ์ฌ๊ธฐ์ NMS๋ Detected ๋ Object์ Bounding box์ค์ ๋น์ทํ ์์น์ ์๋ box๋ฅผ ์ ๊ฑฐํ๊ณ ๊ฐ์ฅ ์ ํฉํ box๋ฅผ ์ ํํ๋ ๊ธฐ๋ฒ ์ ๋๋ค. ์ผ์ข ์ filtering ์ ๋๋ค.
NMS (Non Max Supression)์ ์ํ ๋ก์ง
์ํ Logic์ ๋ค์๊ณผ ๊ฐ์ด ์งํ๋ฉ๋๋ค.
- Detected ๋ bounding box๋ณ๋ก ํน์ Confidence threshold ์ดํ bounding box๋ฅผ ๋จผ์ ์ ๊ฑฐํฉ๋๋ค.
- (Confidence score < 0.5)
- ๊ฐ์ฅ ๋์ confidence score๋ฅผ ๊ฐ์ง box ์์ผ๋ก ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌํ๊ณ ์๋ ๋ก์ง์ ๋ชจ๋ box์ ์์ฐจ์ ์ผ๋ก ์ ์ฉํฉ๋๋ค.
- ๋์ Confidence score๋ฅผ ๊ฐ์ง box์ ๊ฒน์น๋ ๋ค๋ฅธ box๋ฅผ ๋ชจ๋ ์กฐ์ฌํ์ฌ IOU๊ฐ ํน์ threshold ์ด์์ธ box๋ฅผ ๋ชจ๋ ์ ๊ฑฐํฉ๋๋ค.
- (์: IOU Threshold > 0.4 )
- ์ฆ, Confidence Score๊ฐ ์ ์ผ ๋์๊ฒ๋ง ์ฐ๋ค๋ ์๋ฏธ์ ๋๋ค.
- ๋จ์ ์๋ box๋ง ์ ํํฉ๋๋ค.
- ์ฃผ์ํ ํน์ง์ Confidence Score๊ฐ ๋์์๋ก, IoU Threshold๊ฐ ๋ฎ์์๋ก ๋ง์ Box๊ฐ ์ ๊ฑฐ๋ฉ๋๋ค.
Object Detection ์ฑ๋ฅ ํ๊ฐ Metric - mAP (mean Average Precision)
mAP (mean Average Precision)๋ ๊ฐ์ฒด ํ์ง(object detection) ๋ถ์ผ์์ ๋ชจ๋ธ์ ์ฑ๋ฅ์ ํ๊ฐํ๋ ๋ฐ ์ฌ์ฉ๋๋ ์ฃผ์ ์งํ ์ค ํ๋์ ๋๋ค.
- ์ค์ Object๊ฐ Detected๋ ์ฌํ์จ(Recall)์ ๋ณํ์ ๋ฐ๋ฅธ ์ ๋ฐ๋(Presion)์ ๊ฐ์ ํ๊ท ํ ์ฑ๋ฅ ์์น ์ ๋๋ค.
- ์ด ๋ฉํธ๋ฆญ์ ๋ค์ํ ํด๋์ค์ ๋ํ ๋ชจ๋ธ์ ์ ํ์ฑ์ ํ๊ฐํ๊ณ , ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ํ๊ท ๋ด์ด ์ ๊ณตํฉ๋๋ค. ํนํ ๋ค์ํ ๊ฐ์ฒด๋ฅผ ํ์งํด์ผ ํ๋ ์ํฉ์์ ๊ทธ ์ฑ๋ฅ์ ์ ์ฒด์ ์ผ๋ก ์ดํดํ๋ ๋ฐ ์ ์ฉํฉ๋๋ค.
mAP์ ๊ณ์ฐ ๋ฐฉ๋ฒ
mAP๋ฅผ ์ดํดํ๊ธฐ ์ํด์๋ ๋จผ์ Precision๊ณผ Recall์ด๋ผ๋ ๋ ๊ธฐ๋ณธ ๊ฐ๋ ์ ์์์ผ ํฉ๋๋ค:
- Precision์ ๋ชจ๋ธ์ด ๊ฐ์ฒด๋ผ๊ณ ํ์งํ ๊ฒ๋ค ์ค ์ค์ ๋ก ๊ฐ์ฒด์ธ ๊ฒ์ ๋น์จ์ ๋๋ค.
- Recall์ ์ค์ ๊ฐ์ฒด ์ค์์ ๋ชจ๋ธ์ด ๊ฐ์ฒด๋ก ํ์งํ ๋น์จ์ ๋๋ค.
- ๊ฐ์ฒด ํ์ง์์๋ ๊ฐ ํด๋์ค์ ๋ํด ์ฌ๋ฌ ๊ฐ์ Precision-Recall ์์ ๊ณ์ฐํ๊ฒ ๋๋๋ฐ, ์ด๋ ๋ค์ํ IoU (Intersection over Union) ์๊ณ๊ฐ์ ์ ์ฉํ์ฌ ์ป์ด์ง๋๋ค.
- ๊ฐ ํด๋์ค์ ๋ํด, Precision์ Recall์ ํจ์๋ก ๊ทธ๋ฆฐ ๊ณก์ ์๋์ ๋ฉด์ ์ Average Precision(AP)์ด๋ผ๊ณ ํฉ๋๋ค.
- ๋ค์ ๋งํด, AP๋ ํด๋น ํด๋์ค์ ๋ํ Precision-Recall ๊ณก์ ์๋์ ๋ฉด์ ์ ๋๋ค.
- mAP๋ ๋ค์๊ณผ ๊ฐ์ด ๊ณ์ฐ๋ฉ๋๋ค:
- ๊ฐ ํด๋์ค๋ณ AP ๊ณ์ฐ: ๋ชจ๋ ํด๋์ค์ ๋ํด AP๋ฅผ ๊ณ์ฐํฉ๋๋ค.
- ํด๋์ค๋ณ AP ํ๊ท ๊ณ์ฐ: ๋ชจ๋ ํด๋์ค์ AP ๊ฐ๋ค์ ํ๊ท ์ ๊ณ์ฐํฉ๋๋ค.
- ๊ทธ๋ฌ๋ฉด ์ฌํ์จ(Recall), ์ ๋ฐ๋(Presion)์ด ๋ฌด์จ๋ง์ผ๊น์? ๊ทธ๊ฑด ๋ค์๊ธ์์ ํ๋ฒ ์์ ๋ณด๊ฒ ์ต๋๋ค.
๋ฐ์ํ
'๐ Computer Vision' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[CV] OpenCV ์์์ฒ๋ฆฌ ๊ฐ์ (0) | 2024.05.19 |
---|---|
[CV] OpenCV ๊ฐ์ (0) | 2024.05.18 |
[CV] Object Detection & Segmentation์ ์ํ ์ฃผ์ Dataset (0) | 2024.05.17 |
[CV] Precision(์ ๋ฐ๋) & Recall(์ฌํ์จ) (0) | 2024.05.15 |
[CV] Object Detection์ ์ดํด (0) | 2024.05.10 |