하리우라

두 카메라 스테레오 캘리브레이션 (ChArUco 기반)

하리우라 — Thu, 2 Apr 2026 15:27:34 +0900

왜 캘리브레이션이 필요한가

카메라는 3D 세계를 2D 이미지로 투영하는 장치입니다. 이 과정에서 두 가지 문제가 생깁니다.

렌즈 왜곡: 실제 직선이 이미지에서 휘어 보임 (배럴/핀쿠션 왜곡)
투영 관계의 불확실성: 픽셀 좌표와 실제 3D 좌표 사이의 수치 관계를 모름

캘리브레이션은 이 두 가지를 수치로 정확히 구하는 과정입니다.

두 카메라를 함께 쓸 때는 추가로 **두 카메라 사이의 상대 위치·자세(외부 파라미터)**도 구해야 합니다. 이것이 있어야 두 이미지를 픽셀 단위로 정렬할 수 있습니다.

캘리브레이션으로 얻는 결과물

결과물의미

cameraMatrix (K)	초점거리(fx, fy), 주점(cx, cy) — 내부 파라미터
distCoeffs	렌즈 왜곡 계수 (k1, k2, p1, p2, ...)
R, T	카메라1 → 카메라2 회전·평행이동 — 스테레오 외부 파라미터
E, F	Essential/Fundamental Matrix — 두 카메라 간 기하학적 제약

왜 ChArUco 보드인가

기존 체커보드 대신 ArUco 마커가 박힌 체커보드를 사용합니다.

체커보드의 단점: 코너가 일부만 보이면 어느 코너인지 ID를 알 수 없음
ChArUco의 장점: 각 코너 근처에 고유 ID 마커가 있어서, 보드가 부분적으로 잘려도 어느 코너인지 식별 가능

실제 환경에서 보드를 다양한 각도로 기울이거나 이미지 가장자리에 걸칠 때 훨씬 안정적으로 동작합니다.

전체 파이프라인

1. ChArUco 보드 제작 및 정의
        ↓
2. 이미지 수집 (카메라1, 카메라2 동기화 쌍)
        ↓
3. 각 이미지에서 ChArUco 코너 검출
        ↓
4. 단일 카메라 내부 파라미터 캘리브레이션 (카메라1, 카메라2 각각 독립적으로)
        ↓
5. 스테레오 캘리브레이션 (외부 파라미터 R, T 산출)
        ↓
6. 이미지 정렬 (스테레오 렉티피케이션 또는 호모그래피)

Step 1. 보드 제작과 코드 정의

보드를 인쇄한 뒤 실제 정사각형 한 변의 길이를 자로 직접 측정합니다. 이 수치가 코드와 일치하지 않으면 스케일이 틀려집니다.

ARUCO_DICT = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_6X6_250)

board = cv2.aruco.CharucoBoard_create(
    squaresX=5,
    squaresY=5,
    squareLength=0.12,   # 실제 측정값 (미터 단위)
    markerLength=0.09,   # ArUco 마커 크기 (squareLength보다 작아야 함)
    dictionary=ARUCO_DICT
)

단위는 미터든 센티미터든 무관하지만 프로젝트 전체에서 일관성이 있어야 합니다. T(평행이동 벡터)의 단위가 여기서 결정됩니다.

Step 2. 이미지 수집 시 주의사항

장수: 최소 15~20쌍 이상 권장
다양성: 다양한 각도, 거리, 화면 내 위치에서 촬영해야 왜곡 계수 추정이 안정적입니다. 한 자세로만 찍으면 특정 방향 왜곡 추정이 부정확해집니다
동기화: 두 카메라의 쌍은 같은 시점에 찍혀야 합니다. 타임스탬프 차이가 크면 스테레오 외부 파라미터가 틀어집니다
프레임 샘플링: 연속 촬영 영상에서 추출할 경우 인접 프레임은 거의 동일하므로 일정 간격(예: 10프레임마다 1장)으로 샘플링하는 것이 효율적입니다

Step 3. ChArUco 코너 검출

검출은 두 단계로 이루어집니다.

def detect_charuco(image, board, dictionary):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) if image.ndim == 3 else image

    # ① ArUco 마커 검출 (어느 코너인지 ID 파악)
    params = cv2.aruco.DetectorParameters_create()
    corners, ids, rejected = cv2.aruco.detectMarkers(gray, dictionary, parameters=params)

    if ids is None or len(ids) == 0:
        return False, None, None

    # ② ChArUco 코너 보간 (마커 사이 교차점을 서브픽셀 정밀도로 계산)
    retval, charuco_corners, charuco_ids = cv2.aruco.interpolateCornersCharuco(
        markerCorners=corners,
        markerIds=ids,
        image=gray,
        board=board
    )

    if charuco_corners is None or len(charuco_ids) == 0:
        return False, None, None

    return True, charuco_corners, charuco_ids

ArUco 마커로 "어느 코너인지"를 파악하고, 실제 정밀 좌표는 체스판 코너(교차점)에서 얻습니다.

Step 4. 단일 카메라 내부 파라미터 캘리브레이션

두 카메라를 독립적으로 각각 캘리브레이션합니다.

ret, cameraMatrix, distCoeffs, rvecs, tvecs = cv2.aruco.calibrateCameraCharuco(
    charucoCorners=all_corners,  # 각 이미지의 코너 좌표 리스트
    charucoIds=all_ids,          # 각 이미지의 코너 ID 리스트
    board=board,
    imageSize=image_size,
    cameraMatrix=None,
    distCoeffs=None,
)
print("RMS reprojection error:", ret)

ret은 RMS 재투영 오차(reprojection error) 입니다. "3D 점을 추정된 파라미터로 다시 2D에 투영했을 때 실제 검출 위치와 얼마나 차이나는가"를 픽셀 단위로 나타냅니다.

RMS 범위상태

0.5px 이하	양호
0.5 ~ 1.0px	보통 (데이터 다양성 부족 가능성)
1.0px 이상	데이터 품질 재검토 필요

Step 5. 스테레오 캘리브레이션

두 카메라가 같은 보드의 같은 코너를 동시에 본 이미지 쌍을 사용합니다. 각 쌍에서 공통으로 보이는 코너 ID를 기준으로 2D 좌표 대응을 만듭니다.

# 공통 코너 ID 추출
common_ids, idx1, idx2 = np.intersect1d(ids_cam1, ids_cam2, return_indices=True)

# 공통 코너의 3D 보드 좌표 및 각 카메라의 2D 좌표
obj_pts     = board.chessboardCorners[common_ids]  # (N, 3)
img_pts_cam1 = corners_cam1[idx1]
img_pts_cam2 = corners_cam2[idx2]

수집한 모든 쌍을 묶어 스테레오 캘리브레이션을 실행합니다.

retval, _, _, _, _, R, T, E, F = cv2.stereoCalibrate(
    objectPoints=objp_list,
    imagePoints1=pts_cam1_list,
    imagePoints2=pts_cam2_list,
    cameraMatrix1=cam1_mtx,
    distCoeffs1=cam1_dist,
    cameraMatrix2=cam2_mtx,
    distCoeffs2=cam2_dist,
    imageSize=image_size,
    flags=cv2.CALIB_FIX_INTRINSIC,
    criteria=(cv2.TERM_CRITERIA_MAX_ITER + cv2.TERM_CRITERIA_EPS, 100, 1e-5)
)
print("Stereo RMS:", retval)

CALIB_FIX_INTRINSIC이 핵심입니다. Step 4에서 구한 내부 파라미터를 고정하고 R과 T만 최적화합니다. 이것이 표준적인 2단계 접근법입니다. 모든 파라미터를 동시에 최적화하면 자유도가 너무 높아져 오히려 불안정해집니다.

Step 6. 결과 활용 — 두 가지 방법

방법 A: 스테레오 렉티피케이션

두 카메라 이미지를 에피폴라 라인이 수평이 되도록 변환합니다. 스테레오 깊이 추정이나 정밀 정렬에 적합합니다.

R1, R2, P1, P2, Q, roi1, roi2 = cv2.stereoRectify(
    cam1_mtx, cam1_dist,
    cam2_mtx, cam2_dist,
    image_size, R, T,
    flags=cv2.CALIB_ZERO_DISPARITY
)

map1, map2 = cv2.initUndistortRectifyMap(
    cam1_mtx, cam1_dist, R1, P1, image_size, cv2.CV_32FC1
)
cam1_rectified = cv2.remap(img_cam1, map1, map2, cv2.INTER_LINEAR)

렉티피케이션 맵(map1, map2)은 한 번만 계산해 저장해두면, 이후 매 프레임마다 cv2.remap만 호출하면 됩니다.

방법 B: 호모그래피로 카메라2 → 카메라1 정렬

R, T, 두 카메라의 내부 파라미터를 알고 있으면 씬이 특정 깊이의 평면에 있다는 가정 하에 투영 변환 행렬(호모그래피 H)을 수식으로 직접 유도할 수 있습니다.

유도된 H를 사용하면 렉티피케이션 없이도 한 카메라의 이미지를 다른 카메라에 맞게 변환할 수 있습니다.

warped = cv2.warpPerspective(img_cam2, H, image_size)

주의: 이 방법은 씬이 단일 평면이라는 가정에 의존합니다. 깊이 변화가 큰 환경에서는 오정렬이 생기므로, 그런 경우에는 방법 A(렉티피케이션)를 권장합니다.

결과 저장 및 재사용

# 저장
np.savez("calib_cam1.npz", cameraMatrix=cam1_mtx, distCoeffs=cam1_dist)
np.savez("calib_cam2.npz", cameraMatrix=cam2_mtx, distCoeffs=cam2_dist)
np.savez("stereo_calib.npz", R=R, T=T, E=E, F=F)

# 불러오기
data = np.load("stereo_calib.npz")
R, T = data["R"], data["T"]

렉티피케이션 맵도 같은 방식으로 저장해두면 실시간 처리 시 재사용할 수 있습니다.

품질 점검 체크리스트

수집 단계

보드의 squareLength를 실제로 측정했는가
두 카메라 쌍의 타임스탬프 차이가 충분히 작은가
다양한 각도/거리/위치에서 15장 이상 촬영했는가

캘리브레이션 단계

단일 카메라 RMS < 0.5px
스테레오 RMS < 1.0px
언디스토션 이미지에서 직선이 실제로 직선으로 보이는가

정렬 결과 확인

렉티피케이션 후 에피폴라 라인이 수평으로 정렬되는가
두 카메라 이미지의 특징점 위치가 일치하는가

마치며

캘리브레이션에서 가장 중요한 것은 코드가 아니라 좋은 데이터를 수집하는 것입니다. 아무리 정확한 알고리즘도 한 자세로만 찍은 이미지로는 왜곡 계수를 제대로 추정하지 못합니다. 다양한 자세로 충분히 수집하고, RMS 오차로 품질을 확인하는 습관을 들이는 것이 핵심입니다.

GPT CLI (Codex) 설치

하리우라 — Tue, 31 Mar 2026 17:49:22 +0900

도커 컨테이너 안에서 GPT CLI (Codex) 설치 및 사용법

1. 설치

# 전역 설치
npm install -g @openai/codex

설치가 완료되면 codex 명령어를 사용할 수 있다.

2. 첫 실행 (자동 인증)

codex

처음 실행하면 자동으로 로그인/인증 프롬프트가 뜬다.
브라우저 인증 또는 토큰 입력 방식으로 진행된다.

3. 기본 사용

codex

CLI 환경에서 바로 GPT 기반 코드 생성/수정 가능
자연어로 명령 입력하면 코드 생성 및 수정 수행

예시:

> create a python script that reads wav files and prints duration

4. 재인증 (로그인 문제 발생 시)

가끔 인증이 꼬일 수 있는데, 이럴 때는 아래처럼 초기화하면 된다.

# 인증 정보 삭제
rm ~/.codex/auth.json

# 다시 실행 (재로그인)
codex

또는 CLI 내부에서:

/logout
/login

5. 업데이트 (선택)

npm update -g @openai/codex

✅ 정리

npm install -g @openai/codex

codex  # 최초 실행 → 인증

(문제 발생 시)
rm ~/.codex/auth.json
codex

# 또는
/logout
/login

팀으로 쓰던 클로드코드가 만료되서 임시로 쓰는 Codex

PTQ와 QDQ

하리우라 — Tue, 3 Mar 2026 16:11:23 +0900

# TFLite INT8 양자화: 우리가 사용한 PTQ와 QDQ의 차이

PyTorch 모델을 Edge TPU용 INT8 TFLite로 변환하면서, 양자화 방식에 대해 정리한다.
우리가 사용한 방식은 **TFLite Native PTQ**이며, 흔히 말하는 **QDQ 방식과는 다르다**.

---

## 우리가 한 것

```
FP32 ONNX (양자화 노드 없음)
    │
    ▼  onnx2tf
FP32 SavedModel
    │
    ▼  TFLiteConverter + calibration 데이터
Full INT8 TFLite
```

핵심은, **ONNX 그래프에는 양자화 관련 노드가 전혀 없다**는 것이다.
ONNX는 순수 FP32 그래프로서 모델 구조를 전달하는 역할만 하고,
양자화는 마지막 단계에서 `TFLiteConverter`가 전부 처리한다.

```python
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8
converter.inference_output_type = tf.int8
tflite_model = converter.convert()
```

`representative_dataset`으로 calibration 데이터(학습 데이터 200개)를 넘기면,
TFLiteConverter가 이 데이터를 FP32 그래프에 통과시키면서 각 레이어의
activation 범위(min/max)를 수집한다. 이 통계를 기반으로 레이어별
scale과 zero\_point를 계산하고, 최종적으로 INT8 TFLite를 생성한다.

결과 TFLite 파일 안에는 Q/DQ 노드 같은 것이 없다.
각 텐서의 양자화 파라미터는 **텐서 메타데이터**에 저장되고,
연산 자체가 INT8로 실행된다.

---

## QDQ 방식은 어떻게 다른가

QDQ(Quantize-DeQuantize)는 **그래프 안에 양자화 노드를 명시적으로 삽입**하는 방식이다.
`onnxruntime.quantization.quantize_static()`이 대표적인 도구다.

```
[FP32 Weight] → QuantizeLinear → DequantizeLinear → Conv2D → Q → DQ → ReLU → Q → DQ → ...
```

calibration 과정은 비슷하다. 데이터를 흘려서 activation 범위를 수집하고
scale/zero\_point를 계산한다. 다만 그 결과를 **그래프 노드로 삽입**한다는 점이 다르다.

QDQ 그래프는 여전히 FP32로 실행된다. Q→DQ 쌍이 실제 양자화 효과를 시뮬레이션할 뿐이다.
이 그래프를 TFLite나 TensorRT 같은 런타임에 넘기면, 런타임이 Q/DQ 노드를 읽어서
해당 레이어를 INT8로 실행할지 결정한다.

---

## 비교

| | QDQ | TFLite Native PTQ (우리 방식) |
|---|---|---|
| 양자화 정보 위치 | ONNX 그래프 안 (Q/DQ 노드) | TFLite 텐서 메타데이터 |
| 양자화 시점 | ONNX 단계에서 | TFLiteConverter 단계에서 |
| calibration 실행 | onnxruntime | TensorFlow |
| ONNX 그래프 상태 | Q/DQ 노드 포함 | 순수 FP32 |
| 실행 방식 | FP32 + 양자화 시뮬레이션 | 진짜 INT8 연산 |
| 양자화 결정 주체 | 변환 도구 (onnxruntime) | 런타임 (TFLiteConverter) |

---

## 왜 PTQ를 선택했는가

1. **타겟이 TFLite이다.** TFLiteConverter가 직접 양자화하면 Edge TPU가 지원하는
   op set에 정확히 맞는 INT8 모델이 나온다. QDQ를 거치면 중간에 한 단계가 더
   생기는데, 그 단계에서 새로운 호환성 문제가 발생할 수 있다.

2. **ONNX는 전달 역할만 하면 된다.** 우리 파이프라인에서 ONNX는
   PyTorch → TensorFlow 세계로 모델 구조를 넘기는 다리일 뿐이다.
   여기에 양자화 정보까지 담을 필요가 없다.

3. **디버깅이 단순하다.** 문제가 생겼을 때 "ONNX 그래프가 맞는가"와
   "양자화가 맞는가"를 분리해서 확인할 수 있다. QDQ 방식은 둘이 섞여 있어
   어느 쪽 문제인지 분리하기 어렵다.

---

## QDQ를 써야 하는 경우는

- **NVIDIA TensorRT**가 타겟일 때. TensorRT는 QDQ ONNX를 네이티브로 지원하고,
  Q/DQ 노드를 보고 어떤 레이어를 INT8로 실행할지 판단한다.
- **레이어별로 양자화를 세밀하게 제어**하고 싶을 때. 특정 레이어는 FP16으로,
  나머지는 INT8로 하는 mixed-precision이 필요하면 QDQ가 적합하다.
- **QAT(Quantization-Aware Training)**를 했을 때. QAT는 학습 중에
  Q/DQ 노드를 삽입해서 양자화 효과를 시뮬레이션하는데, 그 결과 자체가
  QDQ 그래프다.

우리처럼 **PyTorch → TFLite (Edge TPU)** 경로에서는,
ONNX를 FP32로 깨끗하게 유지하고 TFLiteConverter에게 양자화를 맡기는 것이
가장 단순하고 안정적인 선택이었다.

핸즈온 LLM

하리우라 — Thu, 27 Nov 2025 17:44:50 +0900

본인은 비전 AI를 공부했었다.

LLM이라는 명칭이 있기 전에 자연어를 공부했기에 최신 LLM 내용을 공부하기 위해 이 블로그를 통해 글을 작성하고자 한다

Claude code 설치 방법

하리우라 — Tue, 23 Sep 2025 17:50:07 +0900

도커 컨테이너 안에서 nvm + Node.js 설치 순서

1. nvm 설치

# 컨테이너 안에서 실행
apt-get update && apt-get install -y curl

# nvm 설치
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

# nvm 로드 (bash 환경)
export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"

# 설치 확인
nvm --version

2. Node.js 설치

# Node.js LTS 설치 (예: 18 버전)
nvm install 18
nvm use 18
nvm alias default 18

# 확인
node -v
npm -v

3. npm 최신화

npm install -g npm
npm -v

✅ 정리

apt-get update && apt-get install -y curl
nvm 설치 → .nvm 경로 export → nvm --version 확인
nvm install 18 → node -v, npm -v 확인
npm install -g npm 최신화
npm install && npm run start

4. Claude code 설치

npm install -g @anthropic-ai/claude-code

복소 스펙트럼, 스펙트럼 그래프, 스펙트로그램 완벽 정리

하리우라 — Thu, 7 Aug 2025 16:31:53 +0900

오디오 신호 처리에서 자주 헷갈리는 용어들을 한 번에 정리했습니다.

1. 복소 스펙트럼(Complex Spectrum)

정의

FFT(STFT)를 돌리면 각 주파수 빈 k마다 나오는 복소수 값

X[k] = Re{X[k]} + j·Im{X[k]}

실수부(Real): Re{X[k]}
허수부(Imag): Im{X[k]}

복소 스펙트럼이 담고 있는 정보

크기(Magnitude): |X[k]| = √(Re{X[k]}² + Im{X[k]}²)
위상(Phase): ∠X[k] = arctan(Im{X[k]}/Re{X[k]})

STFT 결과 전체를 '복소 스펙트럼'이라고 부르며, 크기와 위상 정보를 모두 담고 있습니다.

2. (진폭) 스펙트럼 그래프(Magnitude Spectrum Plot)

정의

복소 스펙트럼에서 크기(|X[k]|)만 뽑아서 시각화한 것

만드는 과정

크기 정보만 추출: |X[k]|
dB 단위로 변환: 20·log₁₀(|X[k]|)
그래프로 표현:
- X축: 주파수 (로그 스케일)
- Y축: 진폭(dB)

특징

피크 위치: 해당 주파수에 에너지가 많다 → 악기의 기본음·고조파
로그 주파수 축: 저역부터 고역까지 고르게 보이도록

"스펙트럼 그래프"는 복소 스펙트럼의 크기 정보만 골라서 사람이 보기 편하게 시각화한 것

3. 복소 스펙트럼 vs 스펙트럼 그래프 한눈에 비교

구분 복소 스펙트럼 스펙트럼 그래프

값의 형태	복소수 (Real + j·Imag)	실수 (크기 또는 dB)
표현 정보	크기 + 위상	크기만 (보통 dB 스케일)
축 설정	빈(bin) 인덱스 or 주파수(선형)	주파수(로그/선형)
용도	신호 합성·재구성<br>(위상 정보 필요)	주파수 성분 분석·특징 추출<br>(크기 정보만으로 충분)

핵심 정리

"복소 스펙트럼" = 이론·연산 결과 그 자체(크기+위상)
"스펙트럼 그래프" = 크기만 골라서 dB로 변환해 시각화한 것

4. 스펙트럼 vs 스펙트로그램

기본 개념

스펙트럼(한 프레임): 한 순간에서 FFT 수행한 결과
- 크기: |X[k]|
- 위상: ∠X[k]
스펙트로그램(시간-주파수 행렬): 여러 프레임의 스펙트럼을 시간축으로 쌓은 2D 행렬
- n: 프레임 인덱스(시간)
- k: 주파수 빈
S[n,k] = |X[n,k]|

"크기 값을 쌓는다"의 의미

❌ 히스토그램처럼 값을 누적(sum)하는 것이 아님
⭕ 각 프레임의 스펙트럼 벡터를 시간 차원으로 배열하는 것
- 멜 스펙트로그램: |X[n,k]| 사용
- 파워 스펙트로그램: |X[n,k]|² 사용

5. 스펙트로그램의 위상 정보

일반 스펙트로그램(이미지)

위상 정보가 들어가지 않습니다 ❌

이유: 시각화·머신러닝 입력용으로는 크기(또는 로그 크기)만 필요

복소 스펙트로그램

STFT 결과물 자체에는 위상이 남아있음 ⭕

역변환(ifft) 등 재구성 작업 시 위상 정보 필수

부가 설명

위상 스펙트로그램: ∠X[n,k]만 시각화 (잘 안 씀)
복소 스펙트로그램: 크기+위상 모두 저장, 신호 재합성용

최종 요약

복소 스펙트럼: FFT 결과 그 자체 (크기+위상)
스펙트럼 그래프: 크기만 뽑아서 dB로 시각화
스펙트로그램: 시간축으로 쌓은 크기 스펙트럼
일반 스펙트로그램 이미지에는 위상 정보 없음

기억하기: 스펙트로그램은 "시간축으로 쌓은 크기 스펙트럼"이고, 위상 정보는 일반 스펙트로그램 이미지에 포함되지 않는다!

주파수 해상도와 빈(bin)

하리우라 — Fri, 18 Jul 2025 16:07:03 +0900

주파수 해상도와 빈(bin) 개념을 좀 더 쉬운 말로 풀어서 설명해 볼게요.

1. 빈(bin)이란 무엇인가?

STFT를 하면 시간 축마다 연속적인 소리 신호를 잘라서 FFT(푸리에 변환)를 적용해 주파수 성분의 세기를 계산합니다.
이때 FFT가 반환하는 값 하나하나를 우리는 “빈(bin)”이라고 부릅니다.
각 빈은 “이 구간 주파수 대역(Hz) 안에 얼마나 에너지가 모여 있는가”를 나타내는 막대(bar) 하나라고 생각하면 됩니다.

예: bin[0] → 0–31.25Hz
    bin[1] → 31.25–62.5Hz
    …
    bin[512] → 15968.75–16000Hz

2. 빈 개수 (bins) 계산

우리가 n_fft = 1024로 설정했다면,
- 복소수 FFT 결과로는 1024개의 값이 나오지만,
- 실수(real) 신호를 대칭성 때문에 절반만(＋0~＋Nyquist) 쓴다면,
- **1024/2 + 1 = 513**개의 빈(bin)이 생깁니다.

결론: STFT 한 프레임마다 513개의 주파수 “막대”가 생겨요.

3. 주파수 해상도(frequency resolution)란?

**“하나의 bin이 나타내는 주파수 폭”**입니다.
계산식은 매우 간단해요:Δf=샘플링 레이트(sr)n_fft \Delta f = \frac{\text{샘플링 레이트}(sr)}{n\_fft}예를 들어Δf=32000 Hz1024≈31.25 Hz \Delta f = \frac{32000\text{ Hz}}{1024} \approx 31.25\text{ Hz}
즉, 각 bin은 약 31.25 Hz 폭을 담당합니다.

bin 0 → 0~31.25 Hz
bin 1 → 31.25~62.5 Hz
bin 2 → 62.5~93.75 Hz
…

4. 왜 이것이 중요할까?

시간 해상도 vs. 주파수 해상도
- n_fft를 크게 하면 → Δf가 작아져(더 촘촘히, 예: 10 Hz/bin) → 주파수 해상도 ↑
- 하지만 n_fft가 커지면 → 윈도우 길이(시간 길이)도 길어져 → 시간 해상도 ↓
빈 개수 (=513) 만큼 그래프의 세로(주파수) 축이 촘촘해져서,
- 음성에서 낮은 주파수 대역(목소리의 포먼트)과 높은 대역(해머링, 잡음)을
- 구분해서 볼 수 있게 해 줍니다.

요약

빈(bin): FFT 결과의 각 주파수 구간 하나하나(막대)
빈 개수: n_fft/2+1 → 1024/2+1 = 513개
주파수 해상도 Δf: sr / n_fft → 32000/1024 ≈ 31.25 Hz/bin
빈[k]는 주파수 구간 [k * Δf, (k + 1) * Δf]를 의미합니다.

“빈”과 “해상도” 개념을 이해하면,
STFT나 멜 스펙트로그램이
왜 특정 대역에서 에너지가 높거나 낮은지를
해석하는 데 큰 도움이 돼요.

오디오 데이터 증강 : SpecAugment

하리우라 — Thu, 17 Jul 2025 15:15:53 +0900

본 글에서는 SpecAugment 데이터 증강 기법의 세 가지 주요 단계인 Time Warping, Frequency Masking, Time Masking을 소개했습니다.

Time Warping은 TensorFlow의 sparse_image_warp 함수를 활용하여 log-mel-spectrogram을 왜곡하는 방법입니다. 가로축을 시간축(τ), 세로축을 주파수축(ν)으로 간주하고, 중앙 수평선 상의 임의 지점 x∈[W, τ−W]를 선택하여 좌우로 w만큼 이동시켰습니다. 여기서 w는 [0, W] 균등분포에서 샘플링하였고, 이미지 경계의 네 모서리와 양쪽 세로 중간점 총 6개의 앵커 포인트를 고정하여 안정적인 왜곡을 수행했습니다.
Frequency Masking은 mel 주파수 채널 ν 중 연속된 f개의 채널 [f₀, f₀+f)를 0으로 마스킹하는 방법입니다. f는 [0, F] 균등분포에서, 시작 위치 f₀는 [0, ν−f) 범위에서 랜덤하게 선택했습니다. 이를 통해 모델이 특정 주파수 대역 결손에도 견고하게 학습될 수 있도록 했습니다.
Time Masking은 τ개의 시간 단계 중 연속된 t개의 구간 [t₀, t₀+t)를 0으로 마스킹하는 방법입니다. t는 [0, T] 균등분포에서, 시작 위치 t₀는 [0, τ−t) 범위에서 랜덤하게 선정했습니다. 추가로 마스킹 폭이 전체 시간의 p배를 초과하지 않도록 상한을 설정하여 과도한 시간 정보 손실을 방지했습니다.

T: time step, F : 멜 스펙트로그램의 채널(멜 필터뱅크 채널) 개수 기준 분포 파라메터
위 세 가지 증강 기법을 결합함으로써 음성 인식 모델이 다양한 시간-주파수 왜곡 및 결측 상황에도 강인하게 일반화될 수 있도록 했습니다. SpecAugment는 여러 연구에서 인식 성능 향상에 기여한다고 보고되었습니다.