AI Model Deployment MLOps 파이프라인 구축: LLM 시대를 위한 전략

최근 AI 기술은 GPT와 같은 LLM(Large Language Model)의 등장으로 전례 없는 발전을 이루고 있으며, 이러한 강력한 AI 모델들을 실제 서비스에 적용하고 운영하는 것은 더욱 중요해지고 있습니다. 효과적인 AI 모델 배포와 지속적인 관리를 위해서는 MLOps(Machine Learning Operations) 파이프라인 구축이 필수적입니다. 이 글에서는 AI/ML 개발자의 관점에서 MLOps 파이프라인의 핵심 구성 요소와 LLM 시대를 위한 최신 배포 전략, 그리고 실전 구현 코드를 상세히 다룹니다.

MLOps 파이프라인의 핵심 구성 요소

MLOps는 머신러닝 시스템의 개발부터 배포, 운영, 모니터링에 이르는 전 과정을 자동화하고 효율화하는 방법론입니다. 이는 단순히 모델을 배포하는 것을 넘어, 데이터 관리, 모델 학습, 버전 관리, 지속적인 통합 및 배포(CI/CD), 그리고 운영 중인 모델의 성능 모니터링 및 재학습까지 포함하는 포괄적인 접근 방식입니다.

MLOps 파이프라인은 일반적으로 다음과 같은 핵심 구성 요소로 이루어집니다.

1. 데이터 파이프라인: 데이터 수집, 전처리, 검증, 버전 관리
2. 모델 학습 파이프라인: 모델 학습, 평가, 실험 관리, 모델 버전 관리
3. 모델 배포 파이프라인: 학습된 모델을 서비스 가능한 형태로 패키징, 배포, 서빙
4. 모니터링 파이프라인: 배포된 모델의 성능, 데이터 드리프트, 모델 드리프트 감지 및 알림
5. 재학습 파이프라인: 모니터링 결과를 바탕으로 모델 재학습 및 업데이트 자동화

이러한 구성 요소들이 유기적으로 연결될 때, AI 모델은 안정적으로 운영되며 비즈니스 가치를 지속적으로 창출할 수 있습니다.

AI 모델 학습 및 버전 관리

AI 모델 개발 과정에서 가장 중요한 부분 중 하나는 실험의 재현성(Reproducibility)과 모델의 버전 관리입니다. 특히 딥러닝 모델은 학습 과정에서 다양한 하이퍼파라미터, 데이터셋, 코드 변경이 발생하므로 이를 체계적으로 관리해야 합니다.

MLflow를 활용한 실험 및 모델 관리

MLflow는 머신러닝 라이프사이클을 관리하기 위한 오픈소스 플랫폼으로, 특히 실험 추적(MLflow Tracking)과 모델 레지스트리(MLflow Model Registry) 기능이 강력합니다.

• MLflow Tracking: 모델 학습 시 사용된 코드, 파라미터, 메트릭, 결과물(모델 파일) 등을 기록하고 비교할 수 있습니다.
• MLflow Model Registry: 학습된 모델을 중앙 집중식으로 관리하고, 모델 버전 관리, 스테이징(Staging), 프로덕션(Production) 전환 등 모델 배포 라이프사이클을 지원합니다.

다음은 MLflow를 사용하여 모델 학습 실험을 추적하는 간단한 예시 코드입니다.

import mlflow
import mlflow.pyfunc
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# MLflow Tracking 서버 설정 (로컬 파일 시스템 또는 원격 서버)
mlflow.set_tracking_uri("http://localhost:5000") # 예시: 로컬 MLflow UI 서버

with mlflow.start_run(run_name="RandomForest_Iris_Classification"):
    # 데이터 로드 및 분리
    iris = load_iris()
    X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42)

    # 하이퍼파라미터 설정
    n_estimators = 100
    max_depth = 10

    # 모델 학습
    model = RandomForestClassifier(n_estimators=n_estimators, max_depth=max_depth, random_state=42)
    model.fit(X_train, y_train)

    # 예측 및 평가
    predictions = model.predict(X_test)
    accuracy = accuracy_score(y_test, predictions)

    # MLflow에 파라미터, 메트릭 로깅
    mlflow.log_param("n_estimators", n_estimators)
    mlflow.log_param("max_depth", max_depth)
    mlflow.log_metric("accuracy", accuracy)

    # 모델 로깅 (MLflow Model Registry에 등록)
    mlflow.sklearn.log_model(
        sk_model=model,
        artifact_path="random_forest_model",
        registered_model_name="IrisClassifier" # 모델 레지스트리에 등록될 이름
    )

    print(f"Model Accuracy: {accuracy}")
    print(f"MLflow Run ID: {mlflow.active_run().info.run_id}")

이 코드를 실행하면 MLflow UI에서 n_estimators, max_depth와 같은 파라미터, accuracy 메트릭, 그리고 학습된 모델 파일을 확인할 수 있습니다. registered_model_name을 지정하여 모델 레지스트리에 등록하면, 모델의 버전을 관리하고 프로덕션으로 전환하는 과정을 더욱 쉽게 만들 수 있습니다.

LLM 특화 배포 전략

GPT와 같은 LLM은 그 규모와 복잡성 때문에 기존의 머신러닝 모델과는 다른 배포 전략이 필요합니다. 거대한 모델 크기, 높은 추론 지연 시간(Latency), GPU 메모리 사용량 등의 문제를 해결해야 합니다.

1. 효율적인 모델 서빙 프레임워크 활용

LLM을 효율적으로 서빙하기 위해서는 배치 처리, 연속 배치(Continuous Batching), 양자화(Quantization) 등을 지원하는 전용 서빙 프레임워크가 필수적입니다.

• vLLM: PagedAttention 알고리즘을 사용하여 LLM의 키-값 캐시(KV Cache) 메모리 사용을 최적화하고, 높은 처리량(Throughput)과 낮은 지연 시간을 제공합니다.
• Hugging Face TGI (Text Generation Inference): Hugging Face에서 개발한 LLM 서빙 프레임워크로, Rust 기반의 빠르고 효율적인 추론을 지원하며, 양자화, FlashAttention, PagedAttention 등을 통합합니다.
• NVIDIA Triton Inference Server: 다양한 모델 프레임워크(TensorFlow, PyTorch, ONNX 등)를 지원하며, 동적 배치(Dynamic Batching), 모델 앙상블, 멀티 GPU 추론 등의 고급 기능을 제공합니다. LLM 서빙을 위한 백엔드도 지원합니다.

특징 / 프레임워크	vLLM	Hugging Face TGI	NVIDIA Triton Inference Server
주요 최적화	PagedAttention, Continuous Batching	PagedAttention, FlashAttention, Quantization	Dynamic Batching, Multi-GPU, Model Ensemble
타겟 모델	LLM (텍스트 생성)	LLM (텍스트 생성)	다양한 ML/DL 모델, LLM
언어/기반	Python, PyTorch	Rust, Python, Accelerate	C++, Python (Backend), CUDA
설치 용이성	비교적 쉬움 (pip install)	Docker 이미지 제공	Docker 이미지, 복잡한 설정 가능
확장성	High Throughput	Low Latency, High Throughput	High Scalability, Flexibility

2. 모델 경량화 기술 적용

모델의 크기를 줄여 메모리 사용량을 줄이고 추론 속도를 높이는 기술입니다.

• 양자화(Quantization): 모델의 가중치와 활성화 함수를 16비트 부동소수점(FP16)에서 8비트 정수(INT8) 또는 4비트 정수(INT4) 등으로 변환하여 모델 크기를 줄입니다. 이는 GPU 메모리 사용량을 크게 줄이고 추론 속도를 향상시키지만, 모델 성능 저하가 발생할 수 있습니다.
• 지식 증류(Knowledge Distillation): 대규모의 Teacher 모델의 지식을 소규모의 Student 모델로 전이시켜, 소규모 모델이 대규모 모델의 성능을 모방하도록 학습시킵니다.
• 가지치기(Pruning): 모델의 중요하지 않은 가중치나 뉴런을 제거하여 모델을 희소하게 만들어 크기를 줄입니다.

CI/CD를 통한 자동화된 배포

MLOps 파이프라인에서 CI/CD(Continuous Integration/Continuous Deployment)는 모델의 학습부터 배포까지의 과정을 자동화하여 개발 주기를 단축하고 안정성을 높이는 핵심 요소입니다.

GitHub Actions를 활용한 CI/CD 예시

GitHub Actions는 GitHub 저장소에서 직접 CI/CD 워크플로우를 정의하고 실행할 수 있도록 돕는 도구입니다. 다음은 모델 학습 후 Docker 이미지를 빌드하고 컨테이너 레지스트리에 푸시하는 간단한 워크플로우 예시입니다.

# .github/workflows/deploy_model.yml
name: Deploy ML Model

on:
  push:
    branches:
      - main # main 브랜치에 push 될 때마다 실행
    paths:
      - 'model_training/**' # 모델 학습 관련 코드 변경 시

jobs:
  build_and_push_docker:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.9'

      - name: Install dependencies
        run: pip install -r requirements.txt

      - name: Train model (MLflow Tracking 포함)
        run: |
          # MLflow Tracking 서버가 외부에서 접근 가능하도록 설정
          # 예시: 원격 MLflow 서버 또는 Docker 컨테이너 실행
          # mlflow server --host 0.0.0.0 --port 5000 &
          # export MLFLOW_TRACKING_URI="http://your-mlflow-server:5000"
          python model_training/train.py

      - name: Build Docker image
        run: docker build -t your-docker-registry/your-repo/ml-model:latest .
        working-directory: ./model_serving # 모델 서빙 관련 Dockerfile이 있는 디렉토리

      - name: Log in to Docker Hub
        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

      - name: Push Docker image
        run: docker push your-docker-registry/your-repo/ml-model:latest

이 워크플로우는 main 브랜치에 model_training 디렉토리 내의 코드가 푸시될 때마다:

1. 코드를 체크아웃하고 Python 환경을 설정합니다.
2. requirements.txt에 명시된 의존성을 설치합니다.
3. train.py 스크립트를 실행하여 모델을 학습하고 MLflow에 기록합니다.
4. model_serving 디렉토리의 Dockerfile을 사용하여 Docker 이미지를 빌드합니다.
5. Docker Hub(또는 다른 컨테이너 레지스트리)에 로그인합니다.
6. 빌드된 이미지를 컨테이너 레지스트리에 푸시합니다.

이렇게 푸시된 이미지는 Kubernetes와 같은 컨테이너 오케스트레이션 도구를 통해 자동으로 배포될 수 있습니다.

모델 모니터링 및 재학습

모델 배포 후에도 지속적인 모니터링은 모델 성능 유지와 개선을 위해 필수적입니다. 데이터 분포 변화(Data Drift), 모델 성능 저하(Model Drift) 등을 감지하고, 이에 따라 모델을 재학습하는 파이프라인을 구축해야 합니다.

1. 주요 모니터링 지표

• 성능 지표: 모델의 예측 정확도, 정밀도, 재현율, F1-score 등 비즈니스 목표에 맞는 지표.
• 데이터 드리프트: 입력 데이터의 통계적 특성이 학습 데이터와 달라지는 현상.
• 모델 드리프트: 시간이 지남에 따라 모델의 예측 성능이 저하되는 현상.
• 시스템 지표: CPU/GPU 사용량, 메모리 사용량, 네트워크 트래픽, 추론 지연 시간 등.

2. 모니터링 도구

• Prometheus & Grafana: 시스템 지표 및 커스텀 메트릭을 수집하고 시각화하는 데 널리 사용됩니다.
• MLflow Tracking & Model Registry: MLflow는 배포된 모델의 버전을 관리하고, 각 버전별 성능 추적을 통해 모델 드리프트를 감지하는 데 도움을 줍니다.
• Evidently AI, Seldon Alibi Detect: 데이터 드리프트 및 모델 드리프트 감지를 위한 전문 라이브러리입니다.

3. 재학습 파이프라인 구축

모니터링 결과 특정 임계치를 넘어서는 성능 저하가 감지되거나, 새로운 데이터가 충분히 축적되었을 때 모델을 자동으로 재학습하고 배포하는 파이프라인을 구축할 수 있습니다. 이는 위에서 설명한 CI/CD 파이프라인과 연동하여 자동화할 수 있습니다.

실전 예제: 간단한 LLM 서빙 파이프라인 구축

간단한 LLM을 Docker 컨테이너에 담아 FastAPI로 서빙하는 예시를 통해 MLOps 배포 파이프라인의 일부를 실감 나게 살펴보겠습니다. 여기서는 Hugging Face transformers 라이브러리와 bitsandbytes를 사용하여 경량화된 LLM을 로드하고 추론하는 FastAPI 애플리케이션을 구축합니다.

1. model_serving/app/main.py (FastAPI 애플리케이션)

# model_serving/app/main.py
from fastapi import FastAPI
from pydantic import BaseModel
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

app = FastAPI()

# 모델 로드 (경량화를 위해 4bit 양자화된 모델 사용 예시)
# 실제 LLM은 크기가 매우 크므로, 미리 다운로드하거나 더 작은 모델을 사용해야 합니다.
# 여기서는 예시를 위해 작은 모델을 사용하거나, 실제 LLM 경로를 지정합니다.
MODEL_NAME = "microsoft/phi-2" # 예시: 작은 모델
# MODEL_NAME = "mistralai/Mistral-7B-Instruct-v0.2" # 실제 LLM의 경우 더 많은 GPU 메모리 필요

tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_NAME,
    torch_dtype=torch.float16, # FP16 사용
    load_in_4bit=True, # 4bit 양자화 로드 (bitsandbytes 필요)
    device_map="auto" # GPU가 있다면 자동으로 GPU에 로드
)
model.eval() # 추론 모드 설정

class PromptRequest(BaseModel):
    prompt: str
    max_new_tokens: int = 50
    temperature: float = 0.7

@app.post("/generate")
async def generate_text(request: PromptRequest):
    inputs = tokenizer(request.prompt, return_tensors="pt").to(model.device)
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=request.max_new_tokens,
            temperature=request.temperature,
            do_sample=True, # 샘플링 기반 생성
            pad_token_id=tokenizer.eos_token_id # 패딩 토큰 ID 설정
        )
    
    generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return {"generated_text": generated_text}

@app.get("/health")
async def health_check():
    return {"status": "ok"}

2. model_serving/requirements.txt

fastapi
uvicorn
transformers
torch
bitsandbytes

3. model_serving/Dockerfile

# model_serving/Dockerfile
FROM nvcr.io/nvidia/pytorch:23.09-py3 # GPU 지원을 위한 NVIDIA PyTorch 이미지 사용

WORKDIR /app

# Python 의존성 설치
COPY model_serving/requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 애플리케이션 코드 복사
COPY model_serving/app/ .

# 모델 다운로드 (컨테이너 빌드 시점에 다운로드하여 이미지에 포함)
# 큰 LLM의 경우 빌드 시 다운로드하면 이미지 크기가 매우 커지므로,
# 런타임에 마운트하거나 별도의 캐시 볼륨을 사용하는 것을 고려해야 합니다.
# 여기서는 예시를 위해 작은 모델을 빌드 시 다운로드합니다.
ENV MODEL_NAME="microsoft/phi-2"
RUN python -c "from transformers import AutoModelForCausalLM, AutoTokenizer; AutoTokenizer.from_pretrained('$MODEL_NAME'); AutoModelForCausalLM.from_pretrained('$MODEL_NAME')"

# 애플리케이션 실행
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

4. Docker 이미지 빌드 및 실행

model_serving 디렉토리에서 다음 명령어를 실행하여 Docker 이미지를 빌드하고 실행할 수 있습니다.

# model_serving 디렉토리에서 실행
docker build -t llm-fastapi-server .
docker run -p 8000:8000 --gpus all llm-fastapi-server

이제 http://localhost:8000/generate 엔드포인트로 프롬프트를 보내 LLM 추론을 수행할 수 있습니다.

curl -X POST "http://localhost:8000/generate" \
     -H "Content-Type: application/json" \
     -d '{"prompt": "The capital of France is", "max_new_tokens": 20}'

이 예제는 MLOps 파이프라인의 배포 단계에서 모델을 컨테이너화하고 API 엔드포인트를 통해 서빙하는 과정을 보여줍니다. 실제 프로덕션 환경에서는 Kubernetes와 같은 오케스트레이션 도구를 사용하여 컨테이너를 관리하고, GPU 리소스 할당, 로드 밸런싱, 자동 확장 등을 처리하게 됩니다.

마무리

AI 모델, 특히 LLM의 복잡성과 규모가 커짐에 따라 MLOps 파이프라인은 단순히 "좋은 것"을 넘어 "필수적인 것"이 되고 있습니다. 데이터 관리부터 모델 학습, 효율적인 배포 전략, 그리고 지속적인 모니터링 및 재학습에 이르는 전 과정을 자동화하고 최적화함으로써, AI 모델은 비즈니스에 실제적인 가치를 제공하고 AI 개발팀은 더욱 민첩하게 혁신할 수 있습니다. 이 글에서 다룬 MLOps 원칙과 LLM 특화 전략, 그리고 실전 코드를 통해 여러분의 AI 모델 배포 파이프라인 구축에 도움이 되기를 바랍니다.