Writing

Polars 성능 최적화: LazyFrame과 SQL 활용법 #6

이번 글에서는 LazyFrame, 데이터 타입, 병렬 처리를 활용한 Polars 성능 최적화 방법을 살펴봅니다. SQL에 익숙한 사용자를 위해 Polars에서 SQL을 사용하는 방법도 함께 다룹니다.

예제는 원문 작성 당시 Polars 1.5를 기준으로 작성했습니다. 다른 버전에서의 동작은 별도로 검증하지 않았습니다.

먼저 필요한 라이브러리를 임포트하고 예제 데이터를 불러와 보겠습니다. (아직 설치를 안 하신 분들이 있다면 지난 글을 참고해서 먼저 설치해 주세요 🛠️)

Pokemon.csv 다운로드

import polars as pl

# 데이터 불러오기
df = pl.read_csv("Pokemon.csv")

1. LazyFrame을 통한 연산 최적화 🔄

LazyFrame은 Polars의 가장 강력한 기능 중 하나입니다. 실제 연산을 즉시 수행하지 않고 필요한 시점까지 지연시켜, 최적의 실행 계획을 수립할 수 있게 해 줍니다.

LazyFrame의 작동 원리

LazyFrame은 다음과 같은 최적화를 자동으로 수행합니다:

  1. Filter Pushdown: 필터링 연산을 가능한 한 데이터 읽기 단계로 이동시켜 처리할 데이터량을 줄입니다.
  2. Projection Pushdown: 필요한 칼럼만 선택하여 메모리 사용을 최적화합니다.
  3. Join Optimization: 여러 테이블을 조인할 때 최적의 순서와 방식을 선택합니다.
  4. Predicate Optimization: 복잡한 필터 조건을 단순화하고 최적화합니다.
lazy_query = (
    df.lazy()
    .filter(pl.col("HP") > 100)
    .group_by("Type 1")
    .agg(
        [
            pl.col("Attack").mean().alias("avg_attack"),
            pl.col("Defense").mean().alias("avg_defense"),
        ]
    )
)

print("최적화된 실행 계획:")
print(lazy_query.explain())

print("실행결과:")
print(lazy_query.collect())

실행 결과

실행 계획:
SORT BY [descending: [true]] [col("Attack")]
  simple π 3/3 ["Name", "Attack", "Speed"]
    Csv SCAN [/tmp/Pokemon.csv]
    PROJECT 4/13 COLUMNS
    SELECTION: col("Type 1") == "Fire"
    ESTIMATED ROWS: 801

실제 실행 결과:
shape: (5, 3)
┌───────────────────────────┬────────┬───────┐
│ Name                      ┆ Attack ┆ Speed │
│ ---                       ┆ ---    ┆ ---   │
│ str                       ┆ i64    ┆ i64   │
╞═══════════════════════════╪════════╪═══════╡
│ BlazikenMega Blaziken     ┆ 160    ┆ 100   │
│ DarmanitanStandard Mode   ┆ 140    ┆ 95    │
│ CharizardMega Charizard X ┆ 130    ┆ 100   │
│ Flareon                   ┆ 130    ┆ 65    │
│ Ho-oh                     ┆ 130    ┆ 90    │
└───────────────────────────┴────────┴───────┘

위 예시에서 lazy_query를 정의할 때는 실행 계획만 수립되고, collect()를 호출하는 시점에 실제 데이터 처리가 이루어집니다.

LazyFrame vs DataFrame 성능 비교

실제로 LazyFrame이 얼마나 효율적인지 살펴보겠습니다:

import time

def measure_performance(query_func):
    start_time = time.time()
    result = query_func()
    end_time = time.time()
    return result, end_time - start_time

eager_result, eager_time = measure_performance(
    lambda: df.filter(pl.col("HP") > 100)
        .group_by("Type 1")
        .agg(pl.col("Attack").mean())
)

lazy_result, lazy_time = measure_performance(
    lambda: df.lazy()
        .filter(pl.col("HP") > 100)
        .group_by("Type 1")
        .agg(pl.col("Attack").mean())
        .collect()
)

print(f"Eager 실행 시간: {eager_time:.4f}초")
print(f"Lazy 실행 시간: {lazy_time:.4f}초")

실행 결과

DataFrame 처리 시간: 0.0452 초
LazyFrame 처리 시간: 0.0128 초
성능 향상: 3.53 배

2. 메모리 최적화 기법 💾

대규모 데이터셋을 다룰 때 메모리 관리는 매우 중요합니다. Polars는 다양한 메모리 최적화 기법을 제공합니다.

Scan 함수를 활용한 효율적인 데이터 읽기

Polars는 scan_csv(), scan_parquet(), scan_ipc() 등 다양한 scan 함수를 제공합니다. 이러한 함수들은 지연 실행(lazy evaluation) 방식으로 데이터를 처리하며 다음과 같은 상황에서 특히 유용합니다:

  • 여러 개의 대용량 파일 처리
  • 복잡한 데이터 처리 파이프라인 최적화
  • 메모리 사용량을 최소화해야 하는 환경
  • 쿼리 실행 계획 최적화가 필요한 경우

💡 아래 예시는 설명을 위한 것으로, Pokemon.csv 데이터셋에서는 실행되지 않습니다.

from pathlib import Path

# 다양한 형식의 파일을  읽기
parquet_files = list(Path("data/").glob("*.parquet"))
csv_files = list(Path("data/").glob("*.csv"))

lazy_frames = [
    *[pl.scan_parquet(f) for f in parquet_files],  # parquet 파일
    *[pl.scan_csv(f) for f in csv_files]           # csv 파일
]

# 데이터 처리 파이프라인 구성
query = (
    pl.concat(lazy_frames)
    .filter(
        (pl.col("date").str.contains("2024")) &     # 필터링은 파일 읽기 시점에서 수행
        (pl.col("value") > 1000)
    )
    .select([                                       # 필요한 컬럼만 선택
        "date",
        "category",
        "value",
        "region"
    ])
    .group_by(["category", "region"])
    .agg([
        pl.col("value").mean().alias("avg_value"),
        pl.count().alias("count")
    ])
    .sort("avg_value", descending=True)
)

print("\n처리 결과:")
print(query.collect())

데이터 타입 최적화

적절한 데이터 타입을 선택하면 메모리 사용량을 크게 줄일 수 있습니다:

optimized_df = df.with_columns(
    [
        pl.col("HP").cast(pl.Int16),
        pl.col("Attack").cast(pl.Int16),
        pl.col("Defense").cast(pl.Int16),
        pl.col("Sp. Atk").cast(pl.Int16),
        pl.col("Sp. Def").cast(pl.Int16),
        pl.col("Speed").cast(pl.Int16),
        pl.col("Generation").cast(pl.Int8),
    ]
)

print("메모리 사용량 비교:")
print(f"최적화 전: {df.estimated_size() / 1024:.2f} KB")
print(f"최적화 후: {optimized_df.estimated_size() / 1024:.2f} KB")

실행 결과

최적화 전 메모리: 82.5 KB
최적화 후 메모리: 24.3 KB
메모리 절감율: 70.5%

3. SQL 기능 활용하기 🔍

Polars는 SQL 쿼리를 직접 실행할 수 있는 기능을 제공합니다. 이를 통해 SQL에 익숙한 사용자들도 쉽게 Polars를 활용할 수 있어 진입장벽을 크게 낮출 수 있습니다.

with pl.SQLContext(pokemon=df) as ctx:
    result = ctx.execute(
        """
        SELECT
            "Type 1" as type,
            AVG(HP) as avg_hp,
            COUNT(*) as count
        FROM pokemon
        WHERE Attack > 100
        GROUP BY "Type 1"
        HAVING COUNT(*) > 5
        ORDER BY avg_hp DESC
    """
    )
    print("실행계획: ")
    print(result)
    print("실행결과: ")
    print(result.collect())

실행 결과

shape: (16, 5)
┌──────────┬───────┬────────┬────────────┬─────────────┐
│ Type 1   ┆ count ┆ avg_hp ┆ avg_attack ┆ avg_defense │
│ ---      ┆ ---   ┆ ---    ┆ ---        ┆ ---         │
│ str      ┆ i64   ┆ f64    ┆ f64        ┆ f64         │
╞══════════╪═══════╪════════╪════════════╪═════════════╡
│ Dragon   ┆ 32    ┆ 83.31  ┆ 112.12     ┆ 86.38       │
│ Fighting ┆ 27    ┆ 69.85  ┆ 96.78      ┆ 65.93       │
│ Ground   ┆ 32    ┆ 73.78  ┆ 95.75      ┆ 84.84       │
│ Rock     ┆ 44    ┆ 65.36  ┆ 92.86      ┆ 100.8       │
│ …        ┆ …     ┆ …      ┆ …          ┆ …           │
│ Ice      ┆ 24    ┆ 72.0   ┆ 72.75      ┆ 71.42       │
│ Psychic  ┆ 57    ┆ 70.63  ┆ 71.46      ┆ 67.68       │
│ Bug      ┆ 69    ┆ 56.88  ┆ 70.97      ┆ 70.72       │
│ Electric ┆ 44    ┆ 59.8   ┆ 69.09      ┆ 66.3        │
└──────────┴───────┴────────┴────────────┴─────────────┘

SQL과 Polars Expr 조합하기

SQL 쿼리 결과는 LazyFrame을 반환하며 이후 polars 문법을 활용하여 추가 처리를 할 수 있습니다:

with pl.SQLContext(pokemon=df) as ctx:
    sql_result = ctx.execute(
        """
        SELECT "Type 1", HP, Attack, Defense
        FROM pokemon
        WHERE HP > 100
    """
    )

    # LazyFrame으로 추가 처리
    final_result = sql_result.with_columns(
        [
            (pl.col("Attack") + pl.col("Defense")).alias("total_power"),
            pl.col("HP").rank().over("Type 1").alias("hp_rank"),
        ]
    ).collect()

    print("실행결과:")
    print(final_result)
shape: (5, 6)
┌───────────────────────┬────────┬────────┬─────────┬─────────────┬─────────────┐
│ Name                  ┆ Type 1 ┆ Attack ┆ Defense ┆ total_power ┆ combat_type │
│ ---                   ┆ ---    ┆ ---    ┆ ---     ┆ ---         ┆ ---         │
│ str                   ┆ str    ┆ i64    ┆ i64     ┆ i64         ┆ str         │
╞═══════════════════════╪════════╪════════╪═════════╪═════════════╪═════════════╡
│ Cloyster              ┆ Water  ┆ 95     ┆ 180     ┆ 275         ┆ 방어형      │
│ GyaradosMega Gyarados ┆ Water  ┆ 155    ┆ 109     ┆ 264         ┆ 공격형      │
│ SwampertMega Swampert ┆ Water  ┆ 150    ┆ 110     ┆ 260         ┆ 공격형      │
│ SlowbroMega Slowbro   ┆ Water  ┆ 75     ┆ 180     ┆ 255         ┆ 방어형      │
│ Kingler               ┆ Water  ┆ 130    ┆ 115     ┆ 245         ┆ 공격형      │
└───────────────────────┴────────┴────────┴─────────┴─────────────┴─────────────┘

🎯 마무리

이번 글에서는 Polars의 성능 최적화와 SQL 기능 활용에 대해 자세히 알아보았습니다. LazyFrame을 활용한 쿼리 최적화를 통해 어떻게 데이터 처리 성능을 향상할 수 있는지 살펴보았고, SQL 친화적인 인터페이스를 통해 기존 SQL 사용자들도 쉽게 Polars를 활용할 수 있다는 것을 확인했습니다.

지금까지 6편에 걸쳐 Polars의 기본부터 고급 기능까지 살펴보았습니다. Polars는 빠른 속도와 직관적인 API, 메모리 효율성 등 많은 장점을 가진 라이브러리입니다. 특히 대용량 데이터 처리에서 그 진가를 발휘하며, pandas 사용자들도 쉽게 전환할 수 있도록 설계되어 있습니다. 이번 기회를 통해 polars를 직접 사용해 보시고 그 매력을 느껴보셨으면 좋겠습니다.

지금까지 긴 글 읽어주셔서 감사합니다 🙇‍♂️

📚 참고자료