파이썬 OpenCV 성능 벤치 timeit cProfile FPS 로깅으로 테스트와 재현 완벽 가이드

파이썬 OpenCV 성능 벤치 timeit cProfile FPS 로깅으로 테스트와 재현 완벽 가이드

🧭 실무 영상 처리에서 신뢰 가능한 속도 측정과 재현 방법을 한 번에 정리했습니다

영상 처리 파이프라인을 만들다 보면 코드가 빠른지, 개선이 실제로 효과가 있는지 애매할 때가 많습니다.
수치가 들쭉날쭉하면 팀 커뮤니케이션도 꼬이고, 배포 후 성능 이슈가 되돌아오기도 하죠.
그래서 많은 분들이 파이썬과 OpenCV 조합에서 테스트·재현을 체계화하고, 공정한 성능 벤치로 의사결정 리스크를 줄이고 싶어합니다.
이 글은 그런 상황을 겨냥해 timeit과 cProfile로 함수·호출 수준을 계측하고, 프레임 단위의 FPS 지표를 정확히 계산하며, 결과를 일관되게 로깅해 팀이 같은 기준으로 비교하도록 돕는 실무형 가이드를 목표로 합니다.

핵심은 간단합니다.
평가 기준을 먼저 고정하고, 입력과 환경을 통제해 재현성을 확보한 뒤, 계측 도구로 병목을 찾고, 숫자를 기록해 비교 가능성을 높이는 것입니다.
파이썬 OpenCV 환경에서 흔히 사용하는 I/O, 전처리, 모델 추론, 후처리의 각 단계마다 어떤 방식으로 시간을 쪼개 측정할지, FPS를 무엇으로 정의할지, 로깅 포맷을 어떻게 설계할지가 결과의 신뢰도를 좌우합니다.
이 글은 그런 선택지를 알기 쉽게 정리해 실무에서 바로 가져다 쓰기 좋은 기준선을 제시합니다.

🚀 파이썬 OpenCV 성능 벤치 개요

파이프라인의 성능을 믿을 만하게 비교하려면 먼저 목표와 기준을 고정해야 합니다.
여기서 목표는 테스트·재현 가능성을 높이고, 수치가 팀과 시간에 따라 일관되게 나오도록 만드는 것입니다.
핵심 도구는 파이썬 표준의 timeit과 cProfile, 그리고 영상 처리 특성에 맞춘 프레임 처리률, 즉 FPS 지표입니다.
세 도구를 서로 보완적으로 사용하면 함수 호출 단위의 미세한 지연과 전체 파이프라인의 처리량을 동시에 점검할 수 있습니다.
환경 고정, 입력 고정, 측정 구간 정의, 로깅 포맷 설계까지 네 가지 축을 갖추면 비교가 공정해집니다.

환경 고정은 CPU 스레드 수, 전원 정책, OpenCV 스레딩 설정, 파이썬 버전과 패키지 버전을 명시하는 것부터 시작합니다.
입력 고정은 동일한 영상 파일, 동일한 해상도와 코덱, 고정된 랜덤 시드와 프레임 샘플링 규칙을 유지하는 것을 뜻합니다.
측정 구간은 I O, 전처리, 추론, 후처리, 디스플레이로 쪼개 각 구간의 시간을 분해하고, 전체 루프의 왕복 지연까지 별도로 기록합니다.
로깅은 CSV와 텍스트 로그를 함께 남겨 재실행 시 비교 가능하도록 하고, 평균·표준편차·최대치 같은 통계값을 포함해야 합니다.
이 모든 과정을 자동화 스크립트로 묶어두면 팀원이 바뀌어도 결과를 재현할 수 있습니다.

🧩 timeit, cProfile, FPS의 역할 구분

timeit은 마이크로 벤치로, 특정 함수나 코드 블록의 평균 실행 시간을 노이즈를 줄여 추정할 때 적합합니다.
cProfile은 호출 그래프 전체를 프로파일링해 어떤 함수가 총 시간을 얼마나 소모했는지, 호출 횟수는 얼마인지 파악하게 해줍니다.
FPS는 루프 수준 처리량을 뜻하며, 영상 프레임 기준의 실효 처리 속도를 직관적으로 보여줍니다.
즉, timeit은 미세, cProfile은 구조, FPS는 최종 사용자 관점에서의 체감 속도를 담당합니다.
세 가지를 함께 쓰면 병목의 위치와 효과를 입체적으로 확인할 수 있습니다.

🧱 재현성을 높이는 체크리스트

• ⚙️패키지 버전과 OS, 파이썬, OpenCV 빌드 옵션을 기록합니다.
• 🧪입력 영상, 해상도, 코덱, 프레임 범위를 고정합니다.
• 🔥워밍업 루프를 두고, 워밍업 구간은 통계에서 제외합니다.
• 🧵cv2.setNumThreads, BLAS 스레드, 전원 모드를 명시합니다.
• 📝평균, 표준편차, 백분위수, 샘플 수를 함께 로깅합니다.

"""
벤치마크 스켈레톤: 환경 고정 + 워밍업 + 루프 FPS 계산 + CSV 로깅
"""
import os, csv, time, random
from statistics import mean, pstdev
from collections import deque
import cv2
import numpy as np

# 1) 환경 고정
os.environ["OMP_NUM_THREADS"] = "1"
os.environ["OPENBLAS_NUM_THREADS"] = "1"
cv2.setNumThreads(1)
random.seed(42)
np.random.seed(42)

# 2) 입력 고정
VIDEO = "sample.mp4"
START, END = 0, 500  # 프레임 범위

# 3) 워밍업
cap = cv2.VideoCapture(VIDEO)
for _ in range(30):
    ok, _ = cap.read()
    if not ok: break

# 4) 측정 루프
times = []
fps_hist = deque(maxlen=60)
last = time.perf_counter()

cap.set(cv2.CAP_PROP_POS_FRAMES, START)
for i in range(START, END):
    ok, frame = cap.read()
    if not ok: break

    t0 = time.perf_counter()
    # 전처리/추론/후처리 자리
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    edges = cv2.Canny(gray, 100, 200)
    # --- 측정 종료
    t1 = time.perf_counter()

    times.append(t1 - t0)
    now = t1
    fps_hist.append(1.0 / max(1e-9, now - last))
    last = now

cap.release()

avg = mean(times)
sd = pstdev(times) if len(times) > 1 else 0.0
fps_avg = mean(fps_hist) if fps_hist else 0.0

# 5) CSV 로깅
with open("bench_results.csv", "w", newline="") as f:
    w = csv.writer(f)
    w.writerow(["metric","value"])
    w.writerow(["op_time_avg_s", f"{avg:.6f}"])
    w.writerow(["op_time_sd_s", f"{sd:.6f}"])
    w.writerow(["loop_fps_avg", f"{fps_avg:.2f}"])
print("done")

⏱️ timeit과 cProfile로 함수 수준 측정

코드의 성능을 세밀히 파악하려면 어떤 부분에서 병목이 발생하는지, 특정 함수 호출이 전체 지연에 얼마나 기여하는지를 알아야 합니다.
이때 파이썬 표준 라이브러리인 timeit과 cProfile은 가장 간단하면서도 강력한 도구입니다.
timeit은 마이크로 벤치마크에 특화되어 있어 특정 함수나 코드 블록을 반복 실행하여 평균 실행 시간을 구할 수 있습니다.
반면 cProfile은 전체 호출 스택을 추적하여 어떤 함수가 얼마나 자주 호출되고, 실행 시간의 총합과 비율이 어떻게 분포하는지를 한눈에 보여줍니다.

예를 들어 OpenCV 기반의 영상 처리 코드에서 색공간 변환, 필터링, 엣지 검출, 그리고 사용자 정의 후처리 함수가 있다면, 각각의 연산 시간이 비슷해 보이더라도 실제로는 호출 횟수나 누적 비중에서 차이가 큽니다.
이럴 때 timeit으로 작은 코드 블록의 반복 실행 시간을 측정하고, cProfile로 전체 함수 호출 그래프를 확인하면 어느 부분을 최적화해야 효과가 가장 큰지 객관적으로 판단할 수 있습니다.

🔍 timeit 사용 예시

import cv2, timeit

code = """
import cv2
img = cv2.imread('sample.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
"""

# 100회 실행 후 평균 시간
avg_time = timeit.timeit(stmt=code, number=100) / 100
print(f"평균 실행 시간: {avg_time:.6f}초")

위 예시는 단순한 색공간 변환 연산을 100번 실행해 평균 실행 시간을 계산합니다.
실제 성능 비교 시에는 I O가 포함되지 않도록 메모리에 이미지를 올려놓고 처리 부분만 측정하는 것이 좋습니다.

📊 cProfile 활용법

import cProfile, pstats

def pipeline():
    import cv2
    img = cv2.imread('sample.jpg')
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    edges = cv2.Canny(gray, 50, 150)
    return edges

profiler = cProfile.Profile()
profiler.enable()
for _ in range(100):
    pipeline()
profiler.disable()

stats = pstats.Stats(profiler).sort_stats("cumulative")
stats.print_stats(10)  # 상위 10개 함수 출력

cProfile 출력에서는 함수별 호출 횟수, 누적 실행 시간, 자체 실행 시간을 확인할 수 있습니다.
이를 기반으로 자주 호출되는 병목 함수를 찾아 최적화하거나, 불필요한 반복 호출을 제거하는 전략을 세울 수 있습니다.

🎯 프레임 처리률 FPS 정의와 계산

영상 처리에서 가장 직관적인 성능 지표는 FPS(Frame Per Second)입니다.
FPS는 초당 몇 개의 프레임을 안정적으로 처리할 수 있는지를 의미하며, 사용자 체감 성능을 바로 보여주는 지표로 활용됩니다.
하지만 FPS를 어떻게 정의하고 측정하느냐에 따라 결과가 달라질 수 있습니다.
따라서 정확한 비교와 재현성을 위해서는 FPS 산출 방법을 명확히 합의해야 합니다.

일반적으로 두 가지 방식이 있습니다.
첫째, 전체 프레임 처리에 걸린 시간을 기준으로 평균 FPS를 계산하는 방식입니다.
둘째, 루프마다 1 / (현재시각 - 이전시각)으로 순간 FPS를 구하고 이를 이동 평균으로 산출하는 방법입니다.
실험 목적과 사용자 경험 관점에 따라 선택하는 방법이 달라지지만, 실무에서는 두 수치를 함께 기록해 비교하는 것이 바람직합니다.

📐 FPS 계산 공식

💻 코드 예시

import cv2, time
from statistics import mean
from collections import deque

cap = cv2.VideoCapture("sample.mp4")

frame_count = 0
fps_list = deque(maxlen=60)  # 이동 평균용
last_time = time.perf_counter()
start_time = last_time

while True:
    ret, frame = cap.read()
    if not ret:
        break
    # 처리 로직 (예: 흑백 변환)
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # FPS 측정
    now = time.perf_counter()
    fps_list.append(1.0 / (now - last_time))
    last_time = now
    frame_count += 1

cap.release()

avg_fps = frame_count / (now - start_time)
smooth_fps = mean(fps_list)

print(f"평균 FPS: {avg_fps:.2f}, 최근 60프레임 이동평균 FPS: {smooth_fps:.2f}")

위 코드에서는 전체 평균 FPS와 최근 60프레임 이동 평균 FPS를 함께 구해 안정적인 지표를 제공합니다.
이렇게 계산된 두 값은 각각 장단점이 있으므로, 보고서나 로깅 시 함께 표기하는 습관을 들이면 비교와 검증이 훨씬 명확해집니다.

🧪 반복 가능한 테스트·재현 환경 구성

성능 측정의 신뢰도를 높이려면 무엇보다도 재현 가능한 환경을 확보해야 합니다.
동일한 코드라도 운영체제, CPU 전력 관리, 스레드 수, 라이브러리 버전 등에 따라 결과가 달라질 수 있기 때문입니다.
특히 OpenCV는 내부적으로 스레드 병렬화를 활용하기 때문에, cv2.setNumThreads() 설정에 따라 FPS가 크게 변동할 수 있습니다.

따라서 성능 벤치 환경을 구성할 때는 패키지 버전 고정, 입력 데이터 통제, 실행 시드(seed) 설정, CPU/GPU 자원 정책 통제가 필수입니다.
또한 벤치마크 스크립트에는 환경 정보를 자동으로 로깅하도록 설계해 두면 추후 결과 비교 시 큰 도움이 됩니다.
이는 단순한 실험을 넘어 팀 협업 환경에서 재현 가능성을 보장하는 기본 습관입니다.

⚙️ 환경 재현 체크리스트

• 📦Python, OpenCV, NumPy 등 주요 패키지 버전 명시 및 requirements.txt 저장
• 🖥️CPU 스레드 수, GPU 드라이버 버전, CUDA/cuDNN 버전 기록
• 🎲랜덤 시드 고정 (random.seed, np.random.seed)
• 📂테스트 입력 영상/이미지 파일의 경로와 해시값 기록
• 📝OS 버전, 전원 정책(Performance 모드), OpenCV 스레딩 옵션 기록

🗂️ 환경 정보 자동 로깅 코드

import platform, sys, cv2, numpy as np, os

def log_env_info(path="env_info.txt"):
    with open(path, "w") as f:
        f.write(f"Python: {sys.version}\n")
        f.write(f"Platform: {platform.platform()}\n")
        f.write(f"OpenCV: {cv2.__version__}\n")
        f.write(f"NumPy: {np.__version__}\n")
        f.write(f"OMP_NUM_THREADS: {os.environ.get('OMP_NUM_THREADS')}\n")
        f.write(f"OPENBLAS_NUM_THREADS: {os.environ.get('OPENBLAS_NUM_THREADS')}\n")

log_env_info()
print("환경 정보 로깅 완료")

위 코드처럼 실행 시점의 Python, OpenCV, NumPy 버전과 스레드 환경 변수를 기록해두면, 다른 환경에서 동일한 성능 결과를 재현하는 데 큰 도움이 됩니다.

🗂️ 로깅과 시각화로 결과 저장

벤치마크의 목적은 단순히 수치를 확인하는 것에서 끝나지 않습니다.
중요한 것은 그 결과를 기록하고 공유하여, 이후 최적화 과정이나 팀 협업에서 근거 자료로 활용하는 것입니다.
따라서 로깅과 시각화는 성능 테스트의 마지막이자 필수 단계라 할 수 있습니다.

로깅 포맷은 간결하면서도 분석 가능한 형태여야 합니다.
일반적으로 CSV, JSON, 로그 텍스트를 병행하는 방식을 추천합니다.
CSV는 평균, 표준편차, FPS 같은 수치를 표로 저장하기 좋고, JSON은 환경 설정과 벤치마크 옵션을 기록하기 유용합니다.
텍스트 로그는 사람이 읽기 쉽게 요약을 남겨 문맥을 보완할 수 있습니다.

📊 CSV와 JSON 로깅 예시

import csv, json, time

results = {
    "avg_time": 0.00321,
    "std_time": 0.00015,
    "avg_fps": 28.5,
    "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
}

# CSV 로깅
with open("bench.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(results.keys())
    writer.writerow(results.values())

# JSON 로깅
with open("bench.json", "w") as f:
    json.dump(results, f, indent=4, ensure_ascii=False)

print("로그 저장 완료")

위 예시는 평균 처리 시간, 표준편차, FPS, 실행 시각을 동시에 기록합니다.
이렇게 남긴 로그는 Pandas, Excel, Grafana 등 다양한 분석 도구에서 불러와 쉽게 비교할 수 있습니다.

📈 시각화로 패턴 확인

숫자만으로는 알기 어려운 성능 변동을 한눈에 보기 위해 시각화가 필요합니다.
특히 순간 FPS의 추이를 그래프로 그리면 프레임 드랍이 언제 발생하는지 즉시 파악할 수 있습니다.
Matplotlib나 Seaborn을 활용하면 손쉽게 FPS 히스토리나 연산 시간 분포를 시각화할 수 있습니다.

import matplotlib.pyplot as plt

# 예시 데이터
fps_values = [27, 28, 30, 29, 15, 28, 30, 29, 27, 28]

plt.plot(fps_values, marker="o", color="teal")
plt.title("FPS 추이")
plt.xlabel("프레임 인덱스")
plt.ylabel("FPS")
plt.grid(True)
plt.show()

❓ 자주 묻는 질문 FAQ

🧭 파이썬 OpenCV 벤치 결과 정돈과 활용 요령

이번 글에서는 파이썬 OpenCV 환경에서 테스트·재현을 보장하면서 성능을 신뢰할 수 있게 측정하는 방법을 정리했습니다.
핵심은 timeit과 cProfile로 함수·호출 수준의 시간을 가시화하고, 루프 단위의 프레임 처리률(FPS)을 명확한 정의로 계산하며, 결과를 일관된 스키마로 로깅하는 것입니다.
환경과 입력을 고정해 재현성을 확보하면 비교가 공정해지고, 워밍업 제외와 분산 지표 기록으로 노이즈를 줄일 수 있습니다.
CSV와 JSON, 텍스트 요약을 병행해 기록하고, 그래프 시각화로 순간 드랍과 패턴을 파악하면 최적화 우선순위가 자연스럽게 드러납니다.
스레드 수, 전원 정책, 라이브러리 버전 같은 실행 맥락을 자동 로깅하면 팀원이 달라져도 동일한 결과를 재현할 수 있습니다.
결국 성능 벤치는 한 번의 수치가 아니라 반복 가능한 프로세스이며, 이 프로세스를 표준화할수록 개발 속도와 품질이 함께 개선됩니다.

🏷️ 관련 태그 : 파이썬, OpenCV, 성능벤치마크, timeit, cProfile, FPS, 로깅, 프로파일링, 테스트재현, 영상처리