[YOLO] Object Detection 켄타우로스는 사람일까 동물일까?

https://coding-heading.tistory.com/104

Deep learning[딥러닝] YOLO 객체탐지 네트워크 가중치 모델 사용

 

* 위 글의 가중치 모델을 이용해서 객체(자동차) Detection 하는 코드를 함수로 만들어 보았다.

def predict_yolo(img_path) :
    """이미지 데이터 가져오기"""
    img = cv2.imread(img_path)
    """BGR을 RGB로 변환하기"""
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    height, width, channels = img.shape

    blob = cv2.dnn.blobFromImage(
            img, 
            1/256, 
            (416, 416),
            (0, 0, 0),
            swapRB = True,
            crop = False
    )

    """Yolo 모델에 입력 데이터로 넣어주기"""
    net.setInput(blob)
    outs = net.forward(output_layer)

    ### ----------------------------------------
    """인식된 객체(물체)의 인덱스 번호를 담을 변수"""
    class_ids = []
    """인식된 객체의 인식률(정확도)를 담을 변수"""
    confidences = []
    """인식된 객체의 좌표값을 담을 변수"""
    boxes = []
    
    """출력계층이 반환한 값들을 처리하기 위하여 반복문 사용"""
    for out in outs :
        # print(out)
        """인식된 객체에 대한 정보가 담겨 있음"""
        for detection in out :
            # print(detection)
            """인식된 객체에 대한 정보 추출하기(클래스=레이어 명칭) 확률 정보"""
            scores = detection[5:]
            # print(len(scores), scores)
    
            """scores값이 가장 큰 인덱스 번호 찾기
              - 0은 인식 못했다는 의미
              - 가장 큰 인덱스 값 : 레이블 명칭(이름)이 있는 리스트 배열의 인덱스 값을 의미함
            """
            class_id = np.argmax(scores)
            ### print(class_id)
    
            """score 값이 가장 큰 위치의 인덱스 번호에 해당하는 값은 인식률(정확도)를 의미
            """
            confidence = scores[class_id]
            ### print(confidence)
    
            """정확도(인식률, 탐지율) 50% 이상인 데이터에 대해서 처리하기"""
            if confidence > 0.5 : 
    
                """바운딩 박스의 상태적 중심 x, y 좌표 비율 추출하여
                   - 실제 중심점 길이 좌표(절대 좌표)로 변환하기 
                """
                """실제 중심점 x 좌표"""
                center_x = int(detection[0] * width)
                """실제 중심점 y 좌표"""
                center_y = int(detection[1] * height)
                print(center_x, center_y)
    
                """바운딩 박스의 상대적 너비와 높이 비율 추출하기"""
                """ - 실제 너비로 변환"""
                w = int(detection[2] * width)
                """ - 실제 높이로 변환"""
                h = int(detection[3] * height)
                print(w, h)
    
                """시작점 좌표 계산하기"""
                x = int(center_x - w / 2)
                y = int(center_y - h / 2)
                # print(x, y)
    
                """이미지 좌표계
                  - 좌상단이 0, 0 입니다.
                  - 그래프 좌표계는 좌하단이 0, 0
                """
    
                """실제 x, y, 너비, 높이 값을 리스트로 담기"""
                boxes.append([x, y, w, h])
    
                """객체 인식률(정확도) 실수형 타입으로 담기"""
                confidences.append(float(confidence))
    
                """레이블 명칭(이름) 인덱스 담기"""
                class_ids.append(class_id)
                
    indexes = cv2.dnn.NMSBoxes(boxes, confidences, 0.5, 0.4)   

    ### -------------------------------------------------
    """
    <폰트 스타일 지정>
    """
    font = cv2.FONT_HERSHEY_PLAIN
    
    """
    <바운딩 박스의 색상 지정하기>"""
    colors = np.random.uniform(0, 255, size=(len(boxes), 3))
    
    """인식된 객체가 있는 경우"""
    if len(indexes) > 0 :
        """무조건 1차원으로 변환"""
        # print(indexes.flatten())
        for i in indexes.flatten() : 
            """x, y, w, h 값 추출하기"""
            x, y, w, h = boxes[i]
            # print(x, y, w, h)
    
            """실제 레이블 명칭(이름) 추출하기"""
            label = str(classes[class_ids[i]])
            # print(label)
    
            """인식률(정확도) 추출하기"""
            confidence = str(round(confidences[i], 2))
            # print(confidence)
    
            """바운딩 박스의 색상 추출하기"""
            color = colors[i]
            # print(color)
    
            """바운딩 박스 그리기
                - 마지막 값 2 : 바운딩 박스 선의 굵기
            """
            cv2.rectangle(img, (x, y), ((x+w), (y+h)), color, 2)
    
            """ 인식된 객체의 레이블 명칭(이름)과 정확도 넣기(그리기)"""
            cv2.putText(img, label + " " + confidence,
                        (x, y+20), font, 2, (0, 255, 0), 2)
    
        plt.imshow(img)
        
    ### 인식된 객체가 없는 경우
    else :
        print("인식된 객체가 없습니다!!!")

import glob

paths = glob.glob("./yolo/new_img/can.jpg")

"""함수 호출하기"""
predict_yolo(paths)

결과 :

 

켄타우로스는 사람으로 분류합니다.