Apply를 넘어서 Pandas 연산 가속화하기

소개

데이터 과학 및 분석 분야에서 Pandas는 Python에서 데이터 조작 및 분석을 위한 필수 도구가 되었습니다. 직관적인 DataFrame 및 Series 구조는 복잡한 연산을 단순화하여 실무자들에게 인기 있는 도구입니다. 하지만 데이터셋의 크기와 복잡성이 증가함에 따라 표준 Pandas 연산은 때때로 성능 병목 현상을 일으킬 수 있습니다. 여기서 흔히 사용되는 apply 메서드가 대표적인 예입니다. apply 메서드는 매우 유연하지만, 특히 대규모 데이터셋을 행별 또는 열별로 처리할 때 일반성 대신 성능을 희생하는 경우가 많습니다. 이 글에서는 Pandas에서 고성능 데이터 처리를 위한 apply 메서드의 효율적인 대안 및 기타 전략을 심층적으로 살펴봅니다. 이를 통해 방대한 양의 데이터를 다룰 때도 데이터 파이프라인이 원활하고 빠르게 실행되도록 보장합니다. 이러한 최적화 기술을 이해하는 것은 데이터 분석 노력을 확장하고 강력하고 성능 뛰어난 데이터 기반 애플리케이션을 구축하려는 모든 사람에게 중요합니다.

효율적인 Pandas를 위한 핵심 개념

대안을 자세히 살펴보기 전에 Pandas를 사용하여 고성능 컴퓨팅을 위한 몇 가지 핵심 개념을 정의해 보겠습니다.

• 벡터화 (Vectorization): 개별 요소에 반복하는 대신 전체 배열 또는 Series에 한 번에 연산을 수행하는 것을 의미합니다. NumPy를 기반으로 구축된 Pandas는 벡터화된 연산에 탁월합니다. 각 행을 반복하여 두 열을 더하는 대신, 열을 직접 더합니다 (df['col1'] + df['col2']). 이렇게 하면 연산이 최적화된 C 코드로 위임되어 상당한 속도 향상을 가져옵니다.
• 브로드캐스팅 (Broadcasting): NumPy에서 상속된 강력한 기능인 브로드캐스팅은 호환되는 경우 다른 모양의 배열 간의 연산을 허용하여 호환되는 경우 더 작은 배열을 더 큰 배열에 맞게 자동으로 확장합니다. 이는 명시적인 반복 및 메모리 복제를 방지합니다.
• 범용 함수 (ufuncs): NumPy 배열에 대해 요소별로 작동하는 함수입니다. Pandas Series 및 DataFrame은 고도로 최적화된 연산을 위해 ufuncs를 활용합니다. 예로는 np.sin(), np.sqrt(), np.add() 등이 있습니다.
• 실행 시점 컴파일 (Just-In-Time (JIT) Compilation): Numba와 같은 기술은 Python 코드를 런타임에 고도로 최적화된 머신 코드로 컴파일할 수 있습니다. 이것은 특히 순수 Python에서는 느린 반복적이거나 복잡한 숫자 작업에 대해 계산 속도를 크게 향상시킬 수 있습니다.

apply의 함정과 그 대안

apply 메서드는 다용도이지만 Python 함수를 각 반복에 대해 호출하므로 행별 또는 열별로 작동하기 때문에 종종 성능 병목 현상을 일으킵니다.

이러한 루프와 같은 동작은 벡터화된 Pandas 연산을 지원하는 최적화된 C 확장을 우회합니다.

사용자 지정 메트릭을 각 행에 대해 계산하는 예제를 통해 이를 설명해 보겠습니다.

import pandas as pd
import numpy as np
import time

# 샘플 DataFrame 생성
data_size = 1_000_000
df = pd.DataFrame({
    'col_a': np.random.rand(data_size),
    'col_b': np.random.rand(data_size),
    'col_c': np.random.randint(1, 100, data_size)
})

# 적용할 사용자 지정 함수
def custom_calculation(row):
    return (row['col_a'] * row['col_b']) / row['col_c'] if row['col_c'] != 0 else 0

print("--- .apply() 사용 ---")
start_time = time.time()
df['result_apply'] = df.apply(custom_calculation, axis=1)
end_time = time.time()
print(f".apply() 시간: {end_time - start_time:.4f}초")

백만 행에 대한 apply 결과는 컴퓨터에 따라 몇 초 또는 수십 초가 걸릴 수 있습니다.

대안 1: 벡터화된 연산

가장 기본적이고 종종 가장 효과적인 대안은 벡터화된 연산을 사용하는 것입니다. 많은 사용자 지정 함수는 전체 Series 또는 DataFrame에 작동하는 기본 산술 연산, NumPy 함수 또는 내장 Pandas 메서드를 사용하여 다시 작성할 수 있습니다.

print("\n--- 벡터화된 연산 사용 ---")
start_time = time.time()
df['result_vectorized'] = (df['col_a'] * df['col_b']) / df['col_c']
# 필요한 경우 나중에 0으로 나누기를 명시적으로 처리하거나
# 분모가 0이 되지 않도록 합니다.
# 간단하게 하기 위해 randint(1, 100)에 따라 col_c가 0이 되지 않는다고 가정합니다.
end_time = time.time()
print(f"벡터화된 연산 시간: {end_time - start_time:.4f}초")

# 확인 (결과는 부동 소수점 정밀도를 고려하여 거의 동일해야 합니다)
print(f"결과가 같습니까? {(df['result_apply'] == df['result_vectorized']).all()}")

극적인 속도 향상을 관찰할 수 있습니다. 벡터화된 연산은 최적화된 C 코드를 활용하여 apply보다 수만 배 더 빠릅니다.

대안 2: df.eval() 및 df.query()

복잡한 문자열 기반 표현식의 경우 df.eval()은 numexpr를 사용하여 C에 최적화된 방식으로 표현식을 구문 분석하고 평가하기 때문에 apply보다 훨씬 빠를 수 있습니다. 마찬가지로 df.query()는 필터링 작업을 최적화합니다.

print("\n--- .eval() 사용 ---")
start_time = time.time()
df['result_eval'] = df.eval('col_a * col_b / col_c')
end_time = time.time()
print(f".eval() 시간: {end_time - start_time:.4f}초")

# 일부 데이터를 빠르게 필터링해 봅시다.
print("\n--- .query() 사용 ---")
start_time = time.time()
filtered_df = df.query('col_a > 0.5 and col_c < 50')
end_time = time.time()
print(f".query() 시간: {end_time - start_time:.4f}초")
print(f"필터링된 DataFrame 모양: {filtered_df.shape}")

대안 3: 자동 최적화를 위한 swifter

swifter는 Pandas DataFrame 또는 Series에 함수를 적용하는 가장 효율적인 방법을 지능적으로 결정하려고 시도하는 라이브러리입니다. 이것은 벡터화된 연산을 먼저 시도하고, Dask를 시도한 다음, 함수가 너무 복잡하여 벡터화하기 어려운 경우에만 apply로 대체됩니다.

import swifter # 'swifter'를 설치했는지 확인하십시오: pip install swifter

print("\n--- swifter 사용 ---")
start_time = time.time()
df['result_swifter'] = df.swifter.apply(custom_calculation, axis=1)
end_time = time.time()
print(f"swifter 시간: {end_time - start_time:.4f}초")

swifter는 함수를 쉽게 벡터화할 수 있는지 확실하지 않을 때 편리함과 성능 간의 좋은 균형을 제공할 수 있습니다.

대안 4: JIT 컴파일을 위한 Numba

연산이 복잡하고 쉽게 벡터화될 수 없지만 많은 숫자 계산을 포함하는 경우 Numba는 Python 함수를 머신 코드로 컴파일하여 상당한 속도 향상을 제공할 수 있습니다.

import numba
from numba import guvectorize, float64

# 배열에 대한 요소별 연산을 위한 Numba-jitted 함수 정의
@numba.vectorize(['float64(float64, float64, float64)'])
def numba_calculation_elementwise(col_a, col_b, col_c):
    return (col_a * col_b) / col_c if col_c != 0 else 0

print("\n--- Numba (Vectorize) 사용 ---")
start_time = time.time()
df['result_numba_elementwise'] = 
numba_calculation_elementwise(df['col_a'], df['col_b'], df['col_c'])
end_time = time.time()
print(f"Numba vectorize 시간: {end_time - start_time:.4f}초")


# 벡터화하기 어려운 행별 연산의 경우
@numba.jit(nopython=True)
def custom_calculation_numba(col_a, col_b, col_c):
    return (col_a * col_b) / col_c if col_c != 0 else 0

# 이 jitted 함수 적용
# 참고: JITted 함수에 df.apply()를 직접 적용하면 Pandas 오버헤드로 인해 여전히 느릴 수 있습니다.
# 가장 좋은 방법은 열을 NumPy 배열로 추출하고, Numba 함수를 적용한 다음, 다시 넣는 것입니다.
print("\n--- Numba (JIT 및 재조립) 사용 ---")
start_time = time.time()
df['result_numba_jit_direct'] = [custom_calculation_numba(a, b, c)
for a, b, c in zip(df['col_a'].values, df['col_b'].values, df['col_c'].values)]
end_time = time.time()
print(f"Numba JIT (직접 루프) 시간: {end_time - start_time:.4f}초")

Numba는 사용자 지정 논리에 복잡한 루프 또는 조건문이 포함되어 있고 벡터로 표현하기 어려운 경우에 빛을 발합니다. 핵심은 apply가 여전히 Python 오버헤드를 가져오기 때문에 apply를 사용하여 반복하는 대신 NumPy 배열을 Numba-jitted 함수에 전달하는 것입니다.

결론

apply를 넘어 Pandas 성능을 최적화하는 것은 확장 가능한 데이터 처리에 필수적입니다. 벡터화된 연산을 우선시하고, df.eval() 및 df.query()를 활용하고, swifter와 같은 스마트 라이브러리를 사용하고, 복잡한 숫자 작업에 대해 Numba로 JIT 컴파일을 사용하는 등 데이터 워크플로우를 크게 가속화할 수 있습니다.

주요 원칙은 항상 최적화된 C 코드로 계산을 위임하는 방법을 찾고 가능한 한 느린 Python 루프를 피하는 것입니다. 이러한 전략적 접근 방식은 Pandas 코드를 단순히 기능적인 것에서 탁월하게 빠르게 만드는 것으로 변환할 것입니다.