0. 프로젝트 배경

NIA 수어 데이터셋을 가지고 keypoint 기반 수어 인식 모델을 만드는 팀플을 진행했다. 우선 내가 맡은 역활은 데이터 불러오기 + 데이터 전처리이다. 모델링을 하기 전, 가장 중요한 부분을 맡은 것이다..

처음에는 데이터 구조도 잘 모르고, 일단 돌아가게에 집중했다가,
중간발표 이후에는 진짜 괜찮은 전처리를 만들기 위해 구조를 완전히 손봤다.

1. REAL이 5개라고 믿던 시절 (데이터셋이 5개 밖에 없는 줄 알았슨...)

1-1. 데이터 구조 오해: REAL=5

처음에는 데이터 구조를 이렇게 이해했다.

WORD0001~0160 × REAL01~05 × F 버전

그래서 실제 REAL이 16개라는 걸 모르고,
REAL 01~05만 대상으로 keypoint를 추출했다.

for z in "$SRC"/*.zip; do
  for i in $(seq -f "%04g" 1 160); do
    unzip -qq "$z" "*/NIA_SL_WORD${i}_REAL0[1-5]_F*" -d "$DST"
  done
done

지금 와서 보면,
데이터 16개인 줄 모르고 5개만 쓰면서 데이터가 너무 적다고 고민하고 있었던 시기였다.

1-2. “데이터가 너무 적다” → 데이터 증강부터 고민

REAL이 5개라고 생각하니까, 단어별 샘플 수가 당연히 매우 적어 보였다.

그래서 이때는 전처리 전략의 포커스가

“데이터가 적으니 → 어떻게든 데이터를 늘리자(증강)”

에 맞춰져 있었다.

지금 생각해보면,

데이터가 적다 → 증강! 이라는 생각 자체는 나쁘지 않았지만,
그 전에 데이터가 몇개인지부터 잘 확인했었어야 했다.

1-3. StandardScaler 적용 – skeleton에는 안 맞는 선택

1차 버전에서 또 하나 했던 선택이 StandardScaler였다.

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train.reshape(-1, X_train.shape[-1]))
X_train_scaled = X_train_scaled.reshape(X_train.shape)

당시에는:

딥러닝 전에 feature scaling은 기본이라는 생각으로,

좌표 값 전체를 평균 0, 분산 1로 맞추는 StandardScaler를 적용했다.

근데 skeleton 좌표에 StandardScaler를 쓰면 문제가 생긴다.

각 joint의 상대적인 위치 정보가 왜곡되었다.

또, (x,y)의 “거리 구조”가 흐트러져서, Mid-Hip 기준 거리, 상하/좌우 관계가 깨져버렸다.

1차 버전에서는 이걸 크게 인지하지 못했고, “수치가 잘 정규화되었다” 정도로만 보고 넘어갔다.

1-4. 1차 버전의 한계 정리

정리해보면, REAL=5라고 믿던 시절의 전처리는 이런 느낌이었다.

한 일

• REAL 01~05만 가지고 전처리/학습
• 데이터가 적다고 판단 → 데이터 증강 도입
• StandardScaler로 좌표 전체 스케일링

한계

• REAL을 5개라고 잘못 이해해 전체 데이터의 1/3만 사용
• 데이터가 적다고 판단해 증강(노이즈·프레임 늘리기 등) 적용
• skeleton 좌표에 부적절하게 StandardScaler를 적용해서 구조가 왜곡되었고,
• confidence는 frame 좌표들(x와 y)과 뒤섞인 채로 처리되어, 절반 이상이 0인 데이터를 그대로 사용
• 137개 full keypoint 전체를 입력으로 넣어 차원 큼

이 상태로도 일단 돌아가는 모델은 만들 수 있지만,
데이터 구조를 제대로 이해하고 쓰는 수준은 아니었다.

2. 중간 발표 이후 – “데이터 구조부터 다시 보자”로 전환

중간 발표에서 나왔던 교수님의 핵심 피드백:

• keypoint 차원 축소
• confidence 값이 0인 frame 처리

이걸 계기로 전처리 파이프라인을 처음부터 다시 짰다.

2-1. REAL=16 전체 사용으로 전환

데이터 구조를 다시 보니, 알고 보니 REAL은 5개가 아니라 16개였다.
5개처럼 보였던 건 ‘촬영 각도’였고, 그 아래에 실제 촬영본 REAL01~REAL16이 존재했다.

이걸 뒤늦게 이해해서 zip 파일을 전부 다시 다운로드하고, 패턴을 다시 잡아 전체 160 × 16 × F 버전을 정확히 추출하는 작업을 다시 했다.

2-2. morpheme & keypoint 매칭 다시 하기 (fast_index 재구성)

데이터를 다시 매칭하는데만 10시간정도 걸렸다.. ㅜㅜ

keypoint(frame별 좌표값을 담고 있는 json파일)와 morpheme(수어영상 시작과 끝의 시간 & 단어의미를 담고 있는 json 파일)를 안전하게 매칭하기 위해
fast_index를 다시 만들었다.

word_id = filename.split("_")[2].replace("WORD", "")
real_id = filename.split("_")[3].replace("REAL", "")

key = f"{word_id}_{real_id}"
fast_index[key] = {
    "keypoint": keypoint_path,
    "morpheme": morpheme_path
}

파일이름을 기준으로 WORD / REAL 기준으로 정확한 매칭을 하였고, 실제로 1757개 segment를 안정적으로 확보했다.

2-3. padding → (N, T, 137, 3) 기본 형태 만들기

keypoint_data_list = [item["frames"] for item in data_json]

padded_data = pad_sequences(
    keypoint_data_list,
    padding='post',
    dtype='float32'
)

raw_data = np.array(padded_data)  # (N, T, 137, 3)

모든 sequence를 같은 길이 T로 맞추었다.
각 프레임마다 137개 keypoint × (x, y, conf) 구조로 파악되었다.

2-4. Mid-Hip 상대좌표 (x, y만 변환)

이때부터는 Mid-Hip 기준 상대좌표를 제대로 적용했다.

def apply_midhip_relative(raw):
    N, T, F = raw.shape
    num_points = F // 3
    arr = raw.reshape(N, T, num_points, 3)

    REF = 0  # Mid-Hip
    ref_xy = arr[:, :, REF, :2]      # (N, T, 2)
    ref_xy = ref_xy[:, :, None, :]   # (N, T, 1, 2)

    arr[:, :, :, :2] -= ref_xy       # x,y만 상대좌표 변환
    return arr.reshape(N, T, F)

중요한 점:

이전 버전과 달리, confidence는 건드리지 않았다. (x와 y와 conf 헷갈리지말자!!)
(x, y)만 Mid-Hip을 기준으로 이동시켰다.

2-5. 핵심 keypoint만 추출 (18개 → 54차원)

교수님 피드백 중 하나가:

데이터에 비해 input 차원이 너무 크다.

였다. 그래서 137개 전체 keypoint를 쓰는 대신,
의미 있는 일부만 뽑는 전략으로 갔다.

POSE_IDXS = [0,1,2,3,4,5,6,7]
HAND_IDXS = [4,8,12,16,20]

def select_keypoints(frame_137x3):
    pose = frame_137x3[:25]
    lh   = frame_137x3[25:46]
    rh   = frame_137x3[46:67]

    selected = []
    for idx in POSE_IDXS: selected.append(pose[idx])
    for idx in HAND_IDXS: selected.append(lh[idx])
    for idx in HAND_IDXS: selected.append(rh[idx])

    return np.array(selected).reshape(-1)   # 18 × (x,y,conf) = 54

이렇게 해서:

상체 + 양손의 핵심 포인트만 사용했다.

차원 수를 확 줄이면서, 의미 있는 관절 정보는 유지하는 최상의 방법이였다.

2-6. 가장 큰 이슈였던 confidence = 0 문제 → 보간으로 해결

데이터를 자세히 까보니,
confidence가 0인 값이 전체의 거의 절반이었다.

원인:

차원을 축소하다보니, 손이 가려진 frame들이 많았고, confidence값이 0인 frame들이 연속으로 나오는 경우, 단지 interpolation으로는 보간이 불가했다.

해결 전략: 보간(interpolation) v2

3단계로 설계했다.

(1) forward-fill

for t in range(1, T):
    if conf[t] < th and conf[t-1] >= th:
        x[t] = x[t-1]
        y[t] = y[t-1]
        conf[t] = conf[t-1]

바로 이전 프레임이 신뢰 높으면 → 그 값을 현재 0 위치에 복사

(2) backward-fill

for t in range(T-2, -1, -1):
    if conf[t] < th and conf[t+1] >= th:
        x[t] = x[t+1]
        y[t] = y[t+1]
        conf[t] = conf[t+1]

뒤에서부터 스캔하면서, 뒤에 valid 값이 있으면 앞쪽 빈 칸을 채움

(3) 구간 단위 선형 보간

for s, e in zip(seg_starts, seg_ends):
    prev_t = s - 1
    next_t = e + 1
    if prev_t < 0 or next_t >= T:
        continue

    for t in range(s, e+1):
        ratio = (t - s + 1) / (e - s + 2)
        x[t] = (1-ratio) * x[prev_t] + ratio * x[next_t]
        y[t] = (1-ratio) * y[prev_t] + ratio * y[next_t]
        conf[t] = max(conf[prev_t], conf[next_t])

연속 zero 구간 전체를 앞/뒤 프레임으로 부드럽게 채움, 손이 잠깐 사라졌어도 trajectory가 끊기지 않게 만들어줌

결과

이 과정을 거치고 나서,

confidence 최소값: 1.0 
최대값: 1.0 
0인 값 비율: 0%

즉,

confidence 구멍(0) 문제는 완전히 해결했다.

2-7. 최종 입력: confidence 제거 + 단순 스케일링

보간까지 끝난 후, 최종적으로는 confidence를 입력에서 아예 제거했다.

def remove_confidence(X):
    N,T,F = X.shape
    P = F//3
    coords = X.reshape(N,T,P,3)[:,:,:,:2]   # x,y만
    return coords.reshape(N,T,P*2)          # 36차원

그리고 값이 너무 크지 않도록 1000으로 나누었다.

X_xy /= 1000.0

검증 결과:

최종 x,y 범위: 약 [-1.01 ~ +1.30]

3-sigma 기준 이상치 비율: 0.0024% (거의 없음)

3. 1차 vs 2차 전처리 정리

1차 (REAL=5)

• REAL01~05만 사용 → 데이터 양 자체가 줄어든 상태
• 데이터 적다고 판단해서 증강 쪽에 집중
• StandardScaler로 좌표 전체를 평균 0, 분산 1로 스케일링
• confidence / keypoint 품질에 대한 고민이 부족

2차 (REAL=16)

• REAL01~16 전체 사용
• keypoint–morpheme를 fast_index로 정확히 매칭
• Mid-Hip 기준 (x,y) 상대좌표만 적용
• 핵심 keypoint 18개만 선택해서 차원 축소
• forward/backward + 선형 보간으로 confidence 0 구간 보완
• confidence는 최종 입력에서 제거
• StandardScaler 제거, 좌표는 1000으로 나눈 단순 스케일링
  -> 최종 좌표 범위, 이상치, 분포 모두 깔끔하게 정리

마무리

처음에는 “REAL이 5개인 줄 알았던 시절의 전처리”가 있었고,
그 위에 증강과 StandardScaler를 올려서 어떻게든 돌아가는 모델을 만들려고 했다.

중간발표 이후에는:

데이터 구조를 처음부터 다시 이해하고, keypoint 품질과 confidence를 챙기고, Mid-Hip, 핵심 keypoint 선택, 보간, 스케일링까지 하나씩 논리적으로 쌓아 올리면서 지금의 전처리 파이프라인 v2를 완성했다.

데이터를 전처리하는것도 매우 중요하지만, 데이터 수가 많을 때는 데이터 구조를 먼저 파악하는 것이 중요하다는 생각이 들었다.