[카테고리:] 머신러닝/딥러닝

이미지에 대한 Detection의 한 종류로 Person Keypoints Detection이 있습니다. 이 Detection은 사람의 눈, 코, 귀 그리고 팔과 다리를 검출합니다. 아래처럼요.

머신러닝 라이브리 중에 하나인, PyTorch에서는 Person Keypoints Detection을 위한 모델에 대해서 이미 잘 학습된 데이터를 제공합니다. 이 글은 미리 학습된 데이터를 활용하여 이미지에서 사람의 눈, 코, 귀와 팔 그리고 다리를 검출하는 코드를 살펴봅니다.

아울러 이 글에서는 matplotlib에서 그래프나 이미지를 단순히 표시하는 것에서 원하는 도형을 원하는 위치에 표시하는 API도 파악할 수 있습니다.

먼저 필요한 패키지를 import 합니다.

import numpy as np
from PIL import Image

import torch
import torchvision
from torchvision import models
import torchvision.transforms as T

import matplotlib.pyplot as plt
from matplotlib.path import Path
import matplotlib.patches as patches

미리학습된 데이터를 활용하여 Person Keypoints Detection을 위한 모델을 가져오는데, 머신러닝은 대규모의 행렬연산에 최적화된 GPU에서 수행하는 것이 제맛이므로 GPU 연산을 통해 신경망 모델을 로드합니다.

device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # CPU to GPU
model = models.detection.keypointrcnn_resnet50_fpn(pretrained=True).to(device).eval()

이미지를 불러오고 이미지의 크기를 줄입니다. GPU의 메모리가 충분하다면 이미지를 원본 크기 그대로 사용해도 되지만, 이미지를 가로로 800px로 줄여줍니다. 메모리를 덜 사용하는 것도 있고, 속도도 크게 향상되겠죠.

IMAGE_SIZE = 800
 
img = Image.open('data/running_1.jpg')
img = img.resize((IMAGE_SIZE, int(img.height * IMAGE_SIZE / img.width)))

검출을 수행합니다. 이를 위해 먼저 입력 이미지를 텐서로 변환해야합니다.

trf = T.Compose([
    T.ToTensor()
])

input_img = trf(img).to(device) # CPU to GPU

out = model([input_img])[0]

out 변수에 사람에 대한 눈, 코, 귀 그리고 팔과 다리에 대한 정보가 담겨 있습니다. 이 변수를 이용해 이미지 상에 해당 정보를 시각화 합니다.

codes = [
    Path.MOVETO,
    Path.LINETO,
    Path.LINETO
]

fig, ax = plt.subplots(1)
ax.imshow(img)

THRESHOLD = 0.9 # 해당 정보의 정확도가 90% 이상인 것만 사용

for box, score, keypoints in zip(out['boxes'], out['scores'], out['keypoints']):
    score = score.detach().cpu().numpy() # GPU to CPU

    if score < THRESHOLD:
        continue

    box = box.detach().cpu().numpy() # GPU to CPU
    keypoints = keypoints.detach().cpu().numpy()[:, :2] # GPU to CPU

    # 사람에 대한 영역을 그리기
    rect = patches.Rectangle((box[0], box[1]), box[2]-box[0], box[3]-box[1], linewidth=2, edgecolor='white', facecolor='none')
    ax.add_patch(rect)

    # 왼쪽 팔에 대한 선 그리기
    path = Path(keypoints[5:10:2], codes)
    line = patches.PathPatch(path, linewidth=2, facecolor='none', edgecolor='red')
    ax.add_patch(line)
    
    # 오른쪽 팔에 대한 선 그리기
    path = Path(keypoints[6:11:2], codes)
    line = patches.PathPatch(path, linewidth=2, facecolor='none', edgecolor='red')
    ax.add_patch(line)
    
    # 왼쪽 다리에 대한 선 그리기
    path = Path(keypoints[11:16:2], codes)
    line = patches.PathPatch(path, linewidth=2, facecolor='none', edgecolor='red')
    ax.add_patch(line)
    
    # 오른쪽 다리에 대한 선 그리기
    path = Path(keypoints[12:17:2], codes)
    line = patches.PathPatch(path, linewidth=2, facecolor='none', edgecolor='red')
    ax.add_patch(line)

    # 눈,코,귀는 노란색으로 그리고 팔다리의 시작점과 끝점은 빨간색으로 그리기
    for i, k in enumerate(keypoints):
        if i < 5:
            RADIUS = 5
            FACE_COLOR = 'yellow'
        else:
            RADIUS = 10
            FACE_COLOR = 'red'

        circle = patches.Circle((k[0], k[1]), radius=RADIUS, facecolor=FACE_COLOR)
        ax.add_patch(circle)    

plt.show()    

어제 휴일이라 일찍 잠들었더니, 새벽 3시에 일어났습니다. 글을 작성하던 중에 새벽 4시 조금 넘어서 마켓컬리 배송이 왔네요. 시간을 초월한 마켓컬리의 배송.. 고생이 많으십니당..

이 글은 텐서플로나 파이토치와 같은 같은 딥러닝 라이브러리의 기반을 이해하거나, 직접 개발하고자 할때 참고할 만한 글로 작성한 코드는 이해를 위해 나이브하게 작성했다 . 아래는 이 글에서 사용할 모델로 단순화를 위해 은닉층은 없고 입력층과 출력층만이 존재한다.

입력값 x와 해당 입력값에 대한 라벨값 t는 다음과 같다.

x = np.array([20.1, 32.2])
t = np.array([0, 0, 1])

데이터가 단일 항목인데, 실제는 그 개수가 상당이 많을 것이다. 가중치 W는 입력값의 특성개수가 2개이고 츨력값의 분류수가 3개이므로 2×3 행렬이며, 초기값은 아래처럼 난수로 잡는다.

W = np.random.randn(2, 3)

모델에 대한 입력 데이터가 정해졌으므로, 초기에 난수로 정한 가중치값을 보정하기 위한 방법인 경사하강법에 대한 함수인 gradient를 다음처럼 사용할 수 있다.

dW = gradient(x, t, W)
print(dW)

gradient 함수는 인자로 입력값과 라벨값 그리고 보정할 가중치값이 저장된 행렬을 받으며, 가중치값들을 보정할 경사도(미분값)를 가중치 행렬과 동일한 크기로 반환한다. 먼저 손실함수 loss는 다음과 같다.

def predict(input, weight):
    return np.dot(input, weight)

def softmax(input):
    input = input - np.max(input)
    return np.exp(input) / np.sum(np.exp(input))

def cee(activated, label):
    label = label.argmax(axis=0)
    result = -np.sum(np.log(activated[label] + 1e-7))

    return result    

def loss(input, label, weight):
    output = predict(input, weight)
    activated = softmax(output)
    loss = cee(activated, label)

    return loss

손실함수는 교차 엔트로피 오차(Cross Entropy Error, CEE) 함수를 사용했으며, 출력층에 대한 활성화 함수는 Softmax를 사용한 것을 알 수 있다. 이제 gradient 함수는 아래와 같다.

def gradient(input, label, weight):
    h = 1e-4
    grad = np.zeros_like(weight)
    
    it = np.nditer(weight, flags=['multi_index'])
    while not it.finished:
        idx = it.multi_index
        v = weight[idx]

        weight[idx] = v + h
        fxh1 = loss(input, label, weight)
        
        weight[idx] = v - h 
        fxh2 = loss(input, label, weight)
        
        grad[idx] = (fxh1 - fxh2) / (2*h)
        
        weight[idx] = v

        it.iternext()   
        
    return grad

가중치에 대한 W의 각 요소별로 편미분을 기울기 방향을 구하고 있다. 이 기울기 방향으로 일정한 길이만큼 가중치값을 이동해 주는 것을 반복하면 최소의 손실값을 갖는 가중치들의 모음을 얻을 수 있게 된다. 기울기 방향을 구하기 위한 방법으로 편미분에 대한 수치해석 기법을 활용했으나, 실제 텐서플로우나 파이토치 등과 같은 머신러닝 라이브러리에서는 역전파기법을 활용한다.

사진 이미지는 촬영된 주변 환경에 따라 그 명도나 채도 등이 서로 다릅니다. 이 사진 이미지를 대상으로 하는 머신러닝을 수행하기 전에 이미지들을 동일한 환경으로 맞춰주는 후처리로 전체 이미지에 대한 화소값의 평균과 표준편차를 구해 이 값을 이미지들에 일괄적으로 적용합니다.

아래의 코드는 PyTorch에서 Dataset에 대한 평균과 표준편차를 구하기 위한 코드입니다.

transform = transforms.Compose([
    transforms.ToTensor()
])

dataset = torchvision.datasets.CIFAR10(root='./data/cifar10', train=True, download=True, transform=transform) 

mean = dataset.train_data.mean(axis=(0,1,2))
std = dataset.train_data.std(axis=(0,1,2))

mean = mean / 255
std = std / 255

실제 mean과 std의 값은 각각 [0.4913, 0.4821, 0.4465], [0.2470, 0.2434, 0.2615]와 유사한데, 실제 CIFAR10 데이터를 이용한 딥러닝 예제 코드에서 상수값으로 입력되는 바로 그 값입니다. 실제로 이 평균과 편차는 다음 코드 예시를 통해 적용됩니다.

train_transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(mean, std)
])

train_dataset = torchvision.datasets.CIFAR10(root='./data/cifar10', train=True, download=True, transform=train_transform)