{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2e988dc6",
   "metadata": {},
   "source": [
    "# Part 12: 대규모 AI 모델 최적화 및 서빙\n",
    "\n",
    "**⬅️ 이전 시간: [Part 11: 프로덕션 레벨 MLOps 심화](../11_mlops/part_11_mlops.md)**\n",
    "**➡️ 다음 시간: [Part 13: 생성형 AI 및 AI 에이전트 심화](../13_generative_ai/part_13_generative_ai.md)**\n",
    "\n",
    "---\n",
    "\n",
    "## 1. 학습 목표 (Learning Objectives)\n",
    "\n",
    "> 이 섹션에서는 대규모 AI 모델을 효율적으로 학습시키고, 실제 서비스에 배포하기 위한 최적화 기법들을 학습합니다.\n",
    "\n",
    "- PyTorch FSDP 및 DeepSpeed를 활용하여 대규모 모델을 분산 학습하는 방법을 이해합니다.\n",
    "- 양자화(Quantization), 가지치기(Pruning), 지식 증류(Knowledge Distillation) 등 모델 경량화 기법의 원리를 파악하고 적용할 수 있습니다.\n",
    "- NVIDIA Triton, TorchServe와 같은 고성능 추론 서버를 사용하여 모델 서빙의 처리량과 안정성을 극대화하는 방법을 학습합니다.\n",
    "\n",
    "## 2. 핵심 요약 (Key takeaways)\n",
    "\n",
    "최신 AI 모델의 거대한 크기는 학습과 서빙에 큰 부담을 줍니다. 이를 해결하기 위해 여러 GPU를 활용하는 분산 학습(FSDP, DeepSpeed)으로 학습 한계를 극복하고, 학습이 완료된 모델은 경량화 기법을 통해 최적화합니다. 양자화(Quantization)는 가중치의 데이터 타입을 저용량으로 바꿔 모델 크기를 줄이고, 가지치기(Pruning)는 불필요한 연결을 제거하며, 지식 증류(Knowledge Distillation)는 작은 모델이 큰 모델의 성능을 배우게 합니다. 이러한 최적화를 통해 모델을 더 빠르고, 가볍고, 효율적으로 만들어 실제 서비스에 적용할 수 있습니다.\n",
    "\n",
    "## 3. 도입\n",
    "\n",
    "최신 AI 모델의 크기는 기하급수적으로 증가하고 있으며, 이는 전례 없는 성능 향상을 가져왔지만 동시에 엄청난 컴퓨팅 자원을 요구하는 도전 과제를 안겨주었습니다. Part 12에서는 이처럼 거대한 모델을 현실적인 제약 속에서 어떻게 다룰 수 있는지에 대한 해법을 제시합니다. 여러 GPU를 활용하여 학습의 한계를 돌파하고, 모델의 군살을 빼서 서빙 효율을 높이는 기술들을 통해, 여러분의 AI 모델을 더 빠르고, 더 가볍고, 더 강력하게 만드는 방법을 배우게 될 것입니다.\n",
    "\n",
    "---\n",
    "\n",
    "## 4. 효율적 분산 학습\n",
    "\n",
    "최근 언어 모델(LLM)을 필두로 AI 모델의 파라미터 수는 수천억, 수조 개에 달할 정도로 거대해지고 있습니다. 이처럼 거대한 모델을 단일 GPU 메모리에 올려 학습하는 것은 불가능에 가깝습니다. 설령 메모리가 충분하더라도, 대규모 데이터셋으로 학습을 완료하는 데는 수개월 이상이 소요될 수 있습니다.\n",
    "\n",
    "**분산 학습(Distributed Training)**은 이러한 한계를 극복하기 위해 여러 개의 GPU(또는 여러 노드의 GPU들)를 사용하여 학습을 병렬로 처리하는 기술입니다. 분산 학습을 통해 우리는 다음을 달성할 수 있습니다.\n",
    "\n",
    "- **더 큰 모델 학습**: 단일 GPU의 메모리 한계를 넘어 수십, 수백억 개 파라미터의 모델을 학습시킬 수 있습니다.\n",
    "- **학습 시간 단축**: 여러 GPU가 작업을 나누어 처리함으로써 전체 학습 시간을 획기적으로 줄일 수 있습니다.\n",
    "\n",
    "### 분산 학습의 종류\n",
    "\n",
    "분산 학습은 크게 데이터 병렬 처리와 모델 병렬 처리로 나뉩니다.\n",
    "\n",
    "- **데이터 병렬 처리 (Data Parallelism)**\n",
    "    - 가장 기본적인 분산 학습 방식으로, 여러 GPU에 동일한 모델을 복제하고, 전체 학습 데이터를 미니배치로 나누어 각 GPU에 할당합니다.\n",
    "    - 각 GPU는 할당된 데이터로 모델을 학습하여 그래디언트(gradient)를 계산하고, 모든 GPU의 그래디언트를 동기화하여 모델 파라미터를 업데이트합니다.\n",
    "    - 모델 크기가 단일 GPU에 담길 수 있을 때 효과적입니다.\n",
    "    - PyTorch의 `DistributedDataParallel` (DDP)가 대표적인 예입니다.\n",
    "- **모델 병렬 처리 (Model Parallelism)**\n",
    "    - 모델 자체가 너무 커서 단일 GPU 메모리에 올라가지 않을 때 사용합니다. 모델의 레이어나 파라미터를 여러 GPU에 나누어 배치합니다.\n",
    "    - **텐서 병렬 처리 (Tensor Parallelism)**: 모델의 각 레이어 내부 연산(예: 행렬 곱)을 여러 GPU로 분할하여 처리합니다.\n",
    "    - **파이프라인 병렬 처리 (Pipeline Parallelism)**: 모델의 레이어들을 여러 GPU에 순차적으로 할당하고, 마이크로배치(micro-batch)를 파이프라인처럼 흘려보내며 학습을 진행합니다.\n",
    "    - **ZeRO (Zero Redundancy Optimizer)**: 데이터 병렬처리를 기반으로 하지만, 모델 파라미터, 그래디언트, 옵티마이저 상태(state)까지 여러 GPU에 분할(shard)하여 저장함으로써 메모리 사용량을 극적으로 최적화합니다.\n",
    "\n",
    "---\n",
    "\n",
    "### PyTorch FSDP (Fully Sharded Data Parallel)\n",
    "\n",
    "PyTorch FSDP는 PyTorch 2.0부터 정식으로 포함된 차세대 분산 학습 기술로, ZeRO-3와 유사한 아이디어를 기반으로 구현되었습니다. 데이터 병렬처리를 수행하면서 모델 파라미터, 그래디언트, 옵티마이저 상태를 모든 GPU에 분할하여 저장합니다.\n",
    "\n",
    "**주요 특징:**\n",
    "\n",
    "- **메모리 효율성**: 각 GPU는 전체 파라미터의 일부만 소유하므로, 훨씬 큰 모델을 학습시킬 수 있습니다.\n",
    "- **통신 오버랩**: 연산(computation)과 통신(communication)을 최대한 겹치게(overlap) 설계하여 학습 속도 저하를 최소화합니다.\n",
    "- **PyTorch 통합**: PyTorch에 네이티브하게 통합되어 있어 `DistributedDataParallel` (DDP)에서 마이그레이션하기 비교적 용이합니다.\n",
    "\n",
    "**FSDP 사용법:**\n",
    "\n",
    "FSDP는 모델의 각 레이어를 'FSDP unit'으로 감싸는 방식으로 동작합니다. `auto_wrap` 정책을 사용하면 특정 레이어 타입(예: TransformerBlock)을 지정하여 자동으로 감싸도록 설정할 수 있어 편리합니다.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f42066d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# main.py\n",
    "import torch.distributed as dist\n",
    "from torch.distributed.fsdp import FullyShardedDataParallel as FSDP\n",
    "from torch.distributed.fsdp.wrap import size_based_auto_wrap_policy\n",
    "import functools\n",
    "\n",
    "# ... 분산 환경 설정 (dist.init_process_group) ...\n",
    "\n",
    "model = MyLargeModel()\n",
    "\n",
    "# FSDP 적용\n",
    "# 특정 사이즈보다 큰 모듈을 자동으로 FSDP unit으로 감싸는 정책 사용\n",
    "auto_wrap_policy = functools.partial(\n",
    "    size_based_auto_wrap_policy, min_num_params=1_000_000\n",
    ")\n",
    "model = FSDP(model, auto_wrap_policy=auto_wrap_policy)\n",
    "\n",
    "# ... 이후 학습 루프는 DDP와 유사 ..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f759509a",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "---\n",
    "\n",
    "### Microsoft DeepSpeed\n",
    "\n",
    "DeepSpeed는 Microsoft에서 개발한 대규모 분산 학습 라이브러리로, ZeRO를 포함한 다양한 메모리 최적화 기술과 파이프라인 병렬처리 등을 통합 제공하는 강력한 도구입니다.\n",
    "\n",
    "**주요 특징:**\n",
    "\n",
    "- **ZeRO (Zero Redundancy Optimizer)**: DeepSpeed의 핵심 기술로, 메모리 사용량을 최적화하는 단계별 옵션을 제공합니다.\n",
    "    - **ZeRO-1**: 옵티마이저 상태를 분할합니다.\n",
    "    - **ZeRO-2**: 옵티마이저 상태와 그래디언트를 분할합니다.\n",
    "    - **ZeRO-3**: 옵티마이저 상태, 그래디언트, 모델 파라미터까지 모두 분할합니다. (FSDP와 유사)\n",
    "- **통합 솔루션**: 3D 병렬 처리(데이터, 텐서, 파이프라인)를 모두 지원하며, 대규모 모델 추론(DeepSpeed-Inference) 등 다양한 기능을 제공합니다.\n",
    "- **간편한 설정**: 학습 코드를 거의 수정하지 않고, JSON 설정 파일과 `deepspeed` 런처를 통해 분산 학습을 적용할 수 있습니다.\n",
    "\n",
    "**DeepSpeed 사용법:**\n",
    "\n",
    "1.  **설정 파일 작성 (`ds_config.json`)**\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36f211ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "json\n",
    "{\n",
    "  \"train_batch_size\": 16,\n",
    "  \"optimizer\": {\n",
    "    \"type\": \"Adam\",\n",
    "    \"params\": {\n",
    "      \"lr\": 0.001\n",
    "    }\n",
    "  },\n",
    "  \"fp16\": {\n",
    "    \"enabled\": true\n",
    "  },\n",
    "  \"zero_optimization\": {\n",
    "    \"stage\": 2\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "758ad57e",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "2.  **학습 스크립트 수정**\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04969e32",
   "metadata": {},
   "outputs": [],
   "source": [
    "# training.py\n",
    "import deepspeed\n",
    "\n",
    "# ... 모델, 옵티마이저 등 정의 ...\n",
    "\n",
    "# deepspeed.initialize()를 사용하여 모델 및 옵티마이저를 래핑\n",
    "model_engine, optimizer, _, _ = deepspeed.initialize(\n",
    "    model=model,\n",
    "    optimizer=optimizer,\n",
    "    config=args.deepspeed_config,\n",
    ")\n",
    "\n",
    "# ... 학습 루프 ...\n",
    "# loss = model_engine(data)\n",
    "# model_engine.backward(loss)\n",
    "# model_engine.step()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "757698fb",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "3.  **`deepspeed` 런처로 실행**\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "467f3ed5",
   "metadata": {},
   "outputs": [],
   "source": [
    "deepspeed --num_gpus=4 training.py --deepspeed --deepspeed_config ds_config.json"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8e11cd7",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "### FSDP vs DeepSpeed\n",
    "\n",
    "| 구분 | PyTorch FSDP | Microsoft DeepSpeed |\n",
    "|---|---|---|\n",
    "| **통합성** | PyTorch 네이티브. 생태계와 긴밀하게 통합 | 외부 라이브러리. 별도 설치 및 설정 필요 |\n",
    "| **사용 편의성** | 코드 수정이 더 필요할 수 있음 | JSON 설정 파일 기반으로 코드 수정 최소화 |\n",
    "| **기능** | Sharded Data Parallelism에 집중 | ZeRO, 3D 병렬처리, 추론 최적화 등 종합적인 기능 제공 |\n",
    "| **커뮤니티/지원**| PyTorch 공식 지원 | Microsoft 및 활발한 오픈소스 커뮤니티 |\n",
    "\n",
    "최근에는 FSDP가 PyTorch의 기본 분산 학습 방식으로 자리 잡아가고 있지만, DeepSpeed는 여전히 강력한 기능과 편리함으로 많은 연구 및 프로덕션 환경에서 사용되고 있습니다. 어떤 것을 선택할지는 프로젝트의 요구사항과 개발 환경에 따라 달라질 수 있습니다. \n",
    "\n",
    "---\n",
    "\n",
    "## 5. 모델 경량화 기법\n",
    "\n",
    "대규모 모델은 뛰어난 성능을 보이지만, 막대한 계산 리소스와 메모리를 요구하여 실제 서비스에 배포하고 운영하는 데 큰 부담이 됩니다. 특히 모바일, 엣지 디바이스와 같이 리소스가 제한적인 환경에서는 모델을 그대로 사용하기 어렵습니다.\n",
    "\n",
    "**모델 경량화(Model Quantization)**는 이미 학습된 모델의 성능을 최대한 유지하면서, 모델 크기를 줄이고 추론 속도를 향상시키는 기술들을 총칭합니다. 이를 통해 다음과 같은 이점을 얻을 수 있습니다.\n",
    "\n",
    "- **빠른 추론 속도**: 모델의 연산량이 줄어들어 예측 결과를 더 빠르게 얻을 수 있습니다.\n",
    "- **메모리 사용량 감소**: 모델이 차지하는 메모리와 스토리지 공간이 줄어듭니다.\n",
    "- **온디바이스(On-device) AI 구현**: 스마트폰, IoT 기기 등 엣지 디바이스에 직접 AI 모델을 탑재할 수 있습니다.\n",
    "- **서버 비용 절감**: 더 적은 계산 리소스로 동일한 서비스를 처리할 수 있어 클라우드 비용 등이 절감됩니다.\n",
    "\n",
    "대표적인 모델 경량화 기법으로는 양자화(Quantization), 가지치기(Pruning), 지식 증류(Knowledge Distillation)가 있습니다.\n",
    "\n",
    "### 1. 양자화 (Quantization)\n",
    "\n",
    "**양자화**는 모델의 가중치(weights)와 활성화 함수(activations) 값의 데이터 타입을 더 적은 비트(bit)로 표현하여 모델 크기를 줄이는 가장 널리 사용되는 경량화 기법입니다. 일반적으로 32-bit 부동소수점(FP32)으로 표현되는 실수 값들을 8-bit 정수(INT8)나 16-bit 부동소수점(FP16) 등으로 변환합니다.\n",
    "\n",
    "- **장점**: 모델 크기를 약 1/4(FP32 -> INT8)로 크게 줄일 수 있으며, 정수 연산이 가능한 하드웨어(CPU, GPU, NPU)에서 매우 빠른 추론 속도를 얻을 수 있습니다.\n",
    "- **단점**: 데이터 표현의 정밀도가 낮아져 모델 성능이 약간 저하될 수 있습니다.\n",
    "\n",
    "**주요 양자화 기법:**\n",
    "\n",
    "- **PTQ (Post-Training Quantization)**: 이미 학습된 FP32 모델을 가지고 추가적인 학습 없이 양자화를 수행합니다. 간단하게 적용할 수 있지만, 모델에 따라 성능 하락이 클 수 있습니다.\n",
    "- **QAT (Quantization-Aware Training)**: 모델 학습 과정 자체에 양자화로 인한 오차를 시뮬레이션하여, 양자화 후에도 성능 저하를 최소화하도록 훈련하는 방식입니다. PTQ보다 과정이 복잡하지만 더 좋은 성능을 보장합니다.\n",
    "\n",
    "### 2. 가지치기 (Pruning)\n",
    "\n",
    "**가지치기**는 모델의 성능에 거의 영향을 주지 않는 불필요한 뉴런(neuron)이나 가중치 연결을 제거하여 모델을 희소(sparse)하게 만드는 기법입니다. 마치 나무의 잔가지를 쳐내어 더 튼튼하게 만드는 것과 같습니다.\n",
    "\n",
    "- **장점**: 모델의 파라미터 수를 직접적으로 줄여 크기를 감소시키고, 연산량을 줄여 추론 속도를 향상시킬 수 있습니다.\n",
    "- **단점**: 어떤 가중치를 제거할지 결정하는 기준이 복잡하며, 구조화되지 않은 가지치기는 실제 하드웨어에서 속도 향상으로 이어지기 어려울 수 있습니다.\n",
    "\n",
    "**주요 가지치기 기법:**\n",
    "\n",
    "- **비구조적 가지치기 (Unstructured Pruning)**: 개별 가중치의 중요도를 평가하여 중요도가 낮은 가중치를 하나씩 제거합니다. 모델 압축률은 높지만, 희소한 행렬 연산을 지원하는 특수한 하드웨어가 없으면 속도 향상을 기대하기 어렵습니다.\n",
    "- **구조적 가지치기 (Structured Pruning)**: 채널(channel), 필터(filter), 레이어(layer) 등 특정 구조 단위로 연결을 제거합니다. 모델의 구조가 유지되어 일반적인 하드웨어에서도 속도 향상을 얻기 용이하지만, 비구조적 방식보다 압축률이 낮을 수 있습니다.\n",
    "\n",
    "### 3. 지식 증류 (Knowledge Distillation)\n",
    "\n",
    "**지식 증류**는 크고 복잡하지만 성능이 좋은 **선생님 모델(Teacher Model)**의 지식을 작고 가벼운 **학생 모델(Student Model)**에게 전달하여, 학생 모델이 선생님 모델의 성능을 모방하도록 학습시키는 기법입니다.\n",
    "\n",
    "- **작동 방식**: 학생 모델은 실제 정답(hard label)뿐만 아니라, 선생님 모델의 예측 결과(soft label, 각 클래스에 대한 확률 분포)를 함께 학습합니다. 선생님 모델의 \"정답에 대한 확신도\"까지 학습함으로써, 학생 모델은 더 풍부한 정보를 바탕으로 효율적으로 훈련될 수 있습니다.\n",
    "- **장점**: 완전히 다른 구조의 작은 모델을 만들 수 있어 유연성이 높고, 압축률의 한계가 없습니다. 단독으로 사용되거나 양자화, 가지치기 등 다른 기법과 함께 사용되기도 합니다.\n",
    "- **단점**: 좋은 성능의 선생님 모델을 먼저 확보해야 하며, 학생 모델을 처음부터 학습시켜야 하므로 훈련 비용과 시간이 많이 소요됩니다.\n",
    "\n",
    "---\n",
    "\n",
    "## 6. 연습 문제: BERT 모델 양자화 및 성능 벤치마킹\n",
    "\n",
    "> **🎯 실습 목표:** Hugging Face의 BERT 모델에 8-bit 양자화를 적용하고, 최적화 전후의 모델 크기, 추론 속도(지연 시간), 처리량(Throughput)을 직접 측정하여 경량화의 효과를 눈으로 확인합니다.\n",
    "\n",
    "이론으로 배운 양자화가 실제 NLP 모델에서 어떤 효과를 가져오는지, `transformers`와 `bitsandbytes` 라이브러리를 사용하여 직접 확인해보겠습니다. 이 실습을 통해 우리는 원본 FP32 모델과 INT8로 양자화된 모델의 성능을 구체적인 수치로 비교 분석합니다.\n",
    "\n",
    "**실습 환경:**\n",
    "- **라이브러리:** `torch`, `transformers`, `bitsandbytes`, `accelerate`, `numpy`\n",
    "- **모델:** `bert-base-uncased`\n",
    "- **측정 지표:**\n",
    "    - **모델 크기 (Model Size)**: 모델이 메모리에서 차지하는 용량 (MB)\n",
    "    - **지연 시간 (Latency)**: 단일 추론 요청을 처리하는 데 걸리는 평균 시간 (ms)\n",
    "    - **처리량 (Throughput)**: 1초당 처리할 수 있는 추론 요청의 수 (inferences/sec)\n",
    "\n",
    "### 실습 코드 (`source_code/12_model_optimization/bert_quantization.py`)\n",
    "\n",
    "실습에 사용할 전체 코드는 위 경로에서 확인하실 수 있습니다. 코드의 핵심 로직은 다음과 같습니다.\n",
    "\n",
    "1.  **모델 로딩**: 원본 FP32 `bert-base-uncased` 모델을 로드하고, `load_in_8bit=True` 옵션을 사용하여 동일한 모델을 8-bit 정수형으로 양자화하여 로드합니다.\n",
    "2.  **크기 측정**: 각 모델이 실제 메모리에서 차지하는 크기를 측정하여 비교합니다.\n",
    "3.  **성능 벤치마킹 함수 (`benchmark_performance`)**:\n",
    "    - 정확한 측정을 위해 GPU 예열(warm-up) 과정을 거칩니다.\n",
    "    - 지정된 횟수(예: 100회)만큼 추론을 반복 실행하여 평균 지연 시간과 초당 처리량을 계산합니다.\n",
    "4.  **결과 비교**: 원본 모델과 양자화된 모델의 크기, 지연 시간, 처리량을 일목요연한 표로 정리하여 보여주고, 개선율을 계산하여 출력합니다.\n",
    "\n",
    "### 실습 실행 및 결과 분석\n",
    "\n",
    "아래 명령어를 사용하여 터미널에서 벤치마킹 스크립트를 실행합니다. (CUDA 환경에서 실행 권장)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49e46b8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "python source_code/12_model_optimization/bert_quantization.py"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97db2d30",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "**예상 실행 결과:**\n",
    "\n",
    "스크립트를 실행하면 먼저 각 모델을 로드하고, 벤치마킹을 수행한 후 다음과 같은 최종 성능 비교표를 출력합니다.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd916dac",
   "metadata": {},
   "outputs": [],
   "source": [
    "--- 5. 최종 성능 비교 ---\n",
    "==================================================\n",
    "모델         | 모델 크기(MB)     | 평균 지연시간(ms)        | 처리량(inf/sec)\n",
    "--------------------------------------------------------------------------------------------------\n",
    "FP32       | 417.82          | 15.82                | 63.21\n",
    "INT8       | 134.78          | 9.55                 | 104.71\n",
    "--------------------------------------------------------------------------------------------------\n",
    "📊 모델 크기 감소율: 67.74%\n",
    "⏱️ 지연 시간 개선율: 39.63%\n",
    "🚀 처리량 향상률: 65.65%\n",
    "=================================================="
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26f71d9d",
   "metadata": {},
   "source": [
    "\n",
    "*(참고: 위 결과는 실행 환경의 하드웨어(GPU 종류, 시스템 사양)에 따라 달라질 수 있습니다.)*\n",
    "\n",
    "**결과 분석 (가이드라인):**\n",
    "\n",
    "- **모델 크기**: 양자화를 통해 모델의 메모리 사용량이 약 **68%** 감소했습니다. 이는 FP32(32-bit) 가중치를 INT8(8-bit)로 표현하면서 모델 크기가 이론적으로 1/4 수준으로 줄어들기 때문입니다. (실제 감소율은 레이어 구성 등에 따라 다를 수 있습니다.) 이로 인해 리소스가 제한된 환경에 모델을 배포하기 훨씬 용이해집니다.\n",
    "- **지연 시간 및 처리량**: 추론 속도 또한 크게 향상되었습니다. 평균 지연 시간은 약 **40%** 감소했고, 초당 처리량은 **65%** 이상 증가했습니다. 이는 8-bit 정수 연산이 32-bit 부동소수점 연산보다 하드웨어에서 훨씬 효율적으로 처리되기 때문입니다. 더 빠른 응답 속도와 더 많은 사용자 요청 처리가 가능해져 서빙 비용 효율이 높아집니다.\n",
    "- **추론 정확도**: 스크립트의 마지막 부분을 보면, 두 모델의 추론 결과(레이블 및 점수)가 거의 동일하게 나타나는 것을 확인할 수 있습니다. 이는 `bitsandbytes` 라이브러리가 성능 저하를 최소화하면서 양자화를 효과적으로 수행했음을 보여줍니다.\n",
    "\n",
    "이처럼 양자화는 모델의 정확도에 거의 영향을 주지 않으면서, 모델의 크기와 추론 속도를 극적으로 개선할 수 있는 매우 효과적인 최적화 기법입니다.\n",
    "\n",
    "> **💬 심화: 가지치기(Pruning)와 지식 증류(Knowledge Distillation)**\n",
    ">\n",
    "> 이번 실습에서는 양자화에 집중했지만, 앞서 이론 섹션에서 배운 **가지치기(Pruning)**와 **지식 증류(Knowledge Distillation)** 역시 중요한 경량화 기법입니다. 가지치기는 모델의 불필요한 파라미터를 제거하는 방식이며, 지식 증류는 크고 복잡한 모델의 지식을 작고 효율적인 모델에 전달하는 방식입니다. 실제 프로젝트에서는 모델의 특성과 목표 성능에 따라 이러한 기법들을 단독 혹은 조합하여 사용하게 됩니다.\n",
    "\n",
    "---\n",
    "\n",
    "## 7. 고성능 추론 서버 (Inference Server)\n",
    "\n",
    "모델을 경량화하는 것만큼, 학습된 모델을 효율적으로 서빙하는 것 또한 중요합니다. Python 기반의 웹 프레임워크(예: FastAPI, Flask)는 모델 서빙 API를 빠르고 간단하게 만들 수 있다는 장점이 있지만, 대규모 트래픽 처리나 복잡한 서빙 요구사항에는 한계가 있습니다.\n",
    "\n",
    "**고성능 추론 서버(High-Performance Inference Server)**는 프로덕션 환경에서 머신러닝 모델을 안정적이고 효율적으로 배포하고 운영하기 위해 특별히 설계된 전문 소프트웨어입니다.\n",
    "\n",
    "### 왜 전문 추론 서버가 필요한가?\n",
    "\n",
    "- **처리량(Throughput) 극대화**: 들어오는 요청들을 자동으로 그룹화하여 GPU에서 병렬로 한 번에 처리하는 **동적 배치(Dynamic Batching)** 기능을 통해 GPU 활용률을 극대화하고 처리량을 높입니다.\n",
    "- **다중 모델 서빙**: 단일 서버 인스턴스에서 서로 다른 프레임워크(PyTorch, TensorFlow, ONNX 등)로 만들어진 여러 모델을 동시에 서빙할 수 있습니다.\n",
    "- **동시성(Concurrency)**: 여러 모델을 동시에 실행하거나, 단일 모델의 여러 인스턴스를 동시에 실행하여 여러 요청을 지연 없이 처리할 수 있습니다.\n",
    "- **표준화된 인터페이스**: HTTP/gRPC와 같은 표준 프로토콜을 지원하여 어떤 클라이언트 환경에서도 쉽게 모델 추론을 요청할 수 있습니다.\n",
    "\n",
    "### NVIDIA Triton Inference Server\n",
    "\n",
    "NVIDIA Triton은 클라우드 및 엣지 환경에서 AI 모델 추론을 표준화하기 위해 설계된 오픈소스 추론 서빙 소프트웨어입니다.\n",
    "\n",
    "**주요 특징:**\n",
    "\n",
    "- **다양한 프레임워크 지원**: TensorRT, PyTorch, TensorFlow, ONNX, OpenVINO 등 거의 모든 주요 ML 프레임워크를 지원합니다.\n",
    "- **동적 배치 (Dynamic Batching)**: 서버에 도착하는 개별 추론 요청들을 실시간으로 큐에 모았다가, 지정된 배치 크기(batch size)가 되면 한 번에 묶어 GPU로 보내 처리합니다. 이를 통해 GPU의 병렬 처리 능력을 최대한 활용하여 처리량을 높입니다.\n",
    "- **동시 모델 실행 (Concurrent Model Execution)**: 단일 GPU에서 여러 모델 또는 동일 모델의 여러 인스턴스를 동시에 로드하여, 서로 다른 요청을 병렬로 처리할 수 있습니다.\n",
    "- **모델 저장소 (Model Repository)**: 특정 디렉토리 구조에 맞게 모델 파일을 저장해두면, Triton 서버가 자동으로 모델을 인식하고 로드합니다. 모델 버전 관리, 업데이트, 로드/언로드 등의 기능을 CLI나 API를 통해 제어할 수 있습니다.\n",
    "- **모델 앙상블 (Model Ensemble)**: 여러 모델의 추론 파이프라인을 단일 워크플로우로 묶어 서빙할 수 있습니다. 예를 들어, 전처리 모델 -> 메인 모델 -> 후처리 모델의 흐름을 하나의 앙상블로 정의하여 클라이언트가 한 번의 요청으로 전체 결과를 받을 수 있게 합니다.\n",
    "\n",
    "**Triton 아키텍처:**\n",
    "\n",
    "Triton은 클라이언트/서버 모델로 작동합니다. 클라이언트는 HTTP나 gRPC를 통해 Triton 서버에 추론 요청을 보냅니다. Triton 서버는 모델 저장소에서 모델을 관리하며, 들어온 요청을 스케줄링하고 백엔드(PyTorch, ONNX 등)를 통해 실행하여 결과를 반환합니다.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24035dc6",
   "metadata": {},
   "outputs": [],
   "source": [
    "+----------------+      HTTP/gRPC      +---------------------+\n",
    "|   Client App   | <----------------> |   Triton Server     |\n",
    "+----------------+      Request/Resp.    | +-----------------+ |\n",
    "|                |                     | |  Model Scheduler  | |\n",
    "|                |                     | | (Dynamic Batcher) | |\n",
    "|                |                     | +-----------------+ |\n",
    "|                |                     | |    Backends       | |\n",
    "|                |                     | | - PyTorch       | |\n",
    "|                |                     | | - ONNX          | |\n",
    "|                |                     | | - TensorRT      | |\n",
    "|                |                     | +-----------------+ |\n",
    "|                |                     | | Model Repository  | |\n",
    "+----------------+---------------------+---------------------+"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ceae0559",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "### TorchServe\n",
    "\n",
    "TorchServe는 PyTorch 팀에서 직접 개발하고 관리하는 공식 모델 서빙 라이브러리입니다. PyTorch 모델을 프로덕션 환경에 배포하는 과정을 간소화하는 데 중점을 둡니다.\n",
    "\n",
    "**주요 특징:**\n",
    "\n",
    "- **PyTorch 최적화**: PyTorch 모델 서빙에 가장 최적화되어 있으며, `torch.jit` 스크립트 모델이나 eager 모드 모델을 쉽게 배포할 수 있습니다.\n",
    "- **간편한 사용법**: `torch-model-archiver` CLI를 사용하여 모델과 핸들러를 `.mar` 파일로 아카이빙하고, TorchServe에 등록하여 바로 서빙할 수 있습니다.\n",
    "- **기본 기능 제공**: 로깅, 메트릭 수집, RESTful API 엔드포인트 등 모델 서빙에 필요한 기본적인 기능들을 충실하게 제공합니다.\n",
    "- **동적 배치**: Triton과 마찬가지로 동적 배치 기능을 지원하여 처리량을 향상시킬 수 있습니다.\n",
    "\n",
    "### Triton vs TorchServe\n",
    "\n",
    "| 구분 | NVIDIA Triton | PyTorch TorchServe |\n",
    "|---|---|---|\n",
    "| **범용성** | **다양한 프레임워크 지원** (TF, ONNX, TRT 등) | **PyTorch에 집중** 및 최적화 |\n",
    "| **성능** | GPU 최적화, TensorRT 통합 등 **최고 수준의 성능** | 준수한 성능을 제공하지만 Triton 대비 기능은 적음 |\n",
    "| **기능** | 모델 앙상블, 스트리밍, C++ 백엔드 등 고급 기능 풍부 | 모델 서빙의 핵심 기능에 집중 |\n",
    "| **사용 편의성**| 설정이 다소 복잡할 수 있음 | PyTorch 사용자에게 매우 친숙하고 간편함 |\n",
    "\n",
    "**결론적으로,** 다양한 종류의 모델을 하나의 서버에서 서빙하거나, 최고의 성능 최적화가 필요하다면 **Triton**이 좋은 선택입니다. 반면, 프로젝트가 **PyTorch 중심으로 이루어져 있고**, 빠르고 간편하게 모델을 배포하고 싶다면 **TorchServe**가 효율적인 대안이 될 수 있습니다.\n",
    "\n",
    "---\n",
    "\n",
    "## 8. 캡스톤 프로젝트 연계 미니 프로젝트: 나만의 AI 모델 최적화 및 서빙 전략 수립\n",
    "\n",
    "대규모 모델을 서비스하는 것은 성능뿐만 아니라 '비용'과의 싸움입니다. 이번 미니 프로젝트에서는 이전 챕터에서 만들었던 나만의 모델에 최적화 기법을 직접 적용하여 '가성비'를 높이고, 전문 추론 서버를 사용한 서빙 전략을 수립하여 15장 캡스톤 프로젝트의 기술적 깊이를 더합니다.\n",
    "\n",
    "### 프로젝트 목표\n",
    "- 이전에 학습시킨 모델(예: 7장의 IMDB 감성 분석 PyTorch 모델)에 양자화, 가지치기 등 최소 1개 이상의 경량화 기법을 적용할 수 있습니다.\n",
    "- 최적화 전후 모델의 크기, 추론 지연 시간(Latency), 처리량(Throughput)을 정량적으로 측정하고 비교 분석하여 최적화의 효과를 입증할 수 있습니다.\n",
    "- NVIDIA Triton 또는 TorchServe와 같은 고성능 추론 서버의 역할을 이해하고, 최적화된 모델을 해당 서버에서 운영하기 위한 배포 전략을 문서로 설계할 수 있습니다.\n",
    "\n",
    "### 개발 과정\n",
    "1.  **최적화 대상 모델 선정**:\n",
    "    - 이전 과제에서 만들었던 모델 중 하나를 선택합니다. (예: 7장의 IMDB 감성 분석 PyTorch 모델)\n",
    "\n",
    "2.  **모델 경량화 적용**:\n",
    "    - **(필수)** PyTorch의 `torch.quantization.quantize_dynamic`을 사용하여 모델에 Post-Training Dynamic Quantization을 적용합니다.\n",
    "    - **(도전 과제)** `torch.nn.utils.prune`을 사용하여 가중치 일부를 제거하는 비구조적 가지치기(Unstructured Pruning)를 적용해보고, 양자화와 중복 적용했을 때의 효과를 비교합니다.\n",
    "\n",
    "3.  **성능 벤치마킹**:\n",
    "    - 이 챕터의 `bert_quantization.py` 실습 코드를 참고하여, 여러분의 모델에 맞는 벤치마킹 스크립트를 작성합니다.\n",
    "    - **원본 모델**과 **최적화된 모델** 각각에 대해 아래 지표를 측정하고 표로 정리합니다.\n",
    "        - 모델 파일 크기 (MB)\n",
    "        - 평균 추론 지연 시간 (ms)\n",
    "        - 초당 처리량 (inferences/sec)\n",
    "\n",
    "4.  **고성능 서빙 전략 설계 (문서 작성)**:\n",
    "    - `MY_SERVING_STRATEGY.md` 파일을 생성하고, **Triton**과 **TorchServe** 중 하나를 선택하여 서빙 전략을 수립합니다.\n",
    "    - **모델 리포지토리 구성**: 선택한 추론 서버가 요구하는 모델 저장소의 디렉토리 구조를 설명합니다. (예: `model_repository/my_sentiment_model/1/model.pt`)\n",
    "    - **서버 환경 설정 (`config.pbtxt` 등)**: 모델을 효율적으로 서빙하기 위한 핵심 설정을 어떻게 구성할지 구상합니다.\n",
    "        - **동적 배치(Dynamic Batching)**: 여러 요청을 묶어 처리하기 위한 배치 크기와 지연 시간 설정의 트레이드오프를 설명합니다.\n",
    "        - **인스턴스 그룹(Instance Group)**: 단일 GPU에서 모델을 몇 개나 동시에 실행하여 처리량을 극대화할지 계획을 세웁니다.\n",
    "\n",
    "### 캡스톤 프로젝트 연계 방안\n",
    "- 이 미니 프로젝트에서 최적화한 모델 파일과 서빙 전략 문서는 15장 캡스톤 프로젝트의 **'성능 고도화 및 배포'** 단계에서 그대로 활용될 수 있습니다.\n",
    "- FastAPI 기본 서빙과 전문 추론 서버의 성능 차이를 직접 고민하고 비교해본 경험은, 여러분의 최종 프로젝트가 '프로토타입'을 넘어 '프로덕션 레벨' 서비스로 나아가는 중요한 밑거름이 될 것입니다.\n",
    "- 벤치마킹 결과와 서빙 전략은 최종 발표에서 여러분의 프로젝트가 가진 기술적 깊이와 완성도를 보여주는 강력한 근거 자료가 됩니다.\n",
    "\n",
    "---\n",
    "\n",
    "## 9. 트러블슈팅 (Troubleshooting)\n",
    "\n",
    "- **DeepSpeed/FSDP 실행 시 `CUDA out of memory` 오류가 계속 발생하나요?**\n",
    "    - **원인 분석:** 배치 사이즈, 모델 크기 대비 GPU 메모리가 부족한 경우입니다. ZeRO-3나 FSDP를 사용하더라도, 중간 연산 결과물이나 활성화 함수 출력값이 메모리를 차지하기 때문입니다.\n",
    "    - **해결 방안:**\n",
    "        - `per_device_train_batch_size`를 더 줄여보세요.\n",
    "        - `gradient_accumulation_steps`를 늘려서, 작은 배치로 여러 번 학습한 그래디언트를 모아 한 번에 파라미터를 업데이트하세요. (배치 사이즈를 늘리는 것과 유사한 효과)\n",
    "        - CPU 오프로딩(offloading) 기능을 활성화하여 GPU 메모리가 부족할 때 일부 텐서를 CPU 메모리로 옮기는 옵션을 사용해보세요. (학습 속도는 느려질 수 있습니다.)\n",
    "- **양자화(Quantization) 후 모델 정확도가 너무 많이 떨어지나요?**\n",
    "    - **원인 분석:** PTQ(Post-Training Quantization)는 학습 없이 양자화를 수행하므로, 모델의 특정 레이어가 양자화에 민감하게 반응하여 오차가 크게 발생할 수 있습니다.\n",
    "    - **해결 방안:**\n",
    "        - **QAT (Quantization-Aware Training):** 양자화를 고려하여 추가로 모델을 미세 조정(fine-tuning)하면 정확도 손실을 크게 줄일 수 있습니다.\n",
    "        - **부분 양자화 (Partial Quantization):** 전체 모델이 아닌, 특정 레이어(주로 Conv, Linear)에만 양자화를 적용하거나, 성능 하락에 민감한 레이어는 양자화에서 제외해보세요.\n",
    "- **Triton 서버에서 모델 로드에 실패하나요?**\n",
    "    - **원인 분석:** 모델 저장소의 디렉토리 구조가 잘못되었거나, `config.pbtxt` 파일의 설정이 올바르지 않은 경우가 대부분입니다.\n",
    "    - **해결 방안:**\n",
    "        - [Triton 모델 저장소 문서](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_repository.md)를 참고하여 `config.pbtxt`의 `name`, `platform`, `input`, `output` 설정이 정확한지 다시 한 번 확인하세요.\n",
    "        - 모델 파일의 버전 디렉토리(예: `1/model.pt`)가 제대로 생성되었는지 확인하세요.\n",
    "\n",
    "---\n",
    "\n",
    "## 10. 개념 확인 퀴즈 (Concept Check Quiz)\n",
    "\n",
    "1. DeepSpeed의 ZeRO-2와 ZeRO-3 최적화 레벨의 가장 큰 차이점은 무엇인가요?\n",
    "2. 모델의 가중치를 FP32에서 INT8로 바꾸는 경량화 기법의 이름은 무엇이며, 이로 인해 얻을 수 있는 가장 큰 장점 두 가지는 무엇인가요?\n",
    "3. 동적 배치(Dynamic Batching)가 추론 서버의 처리량(Throughput)을 높이는 원리를 간략히 설명하세요.\n",
    "\n",
    "---\n",
    "\n",
    "## 11. 과제 (Assignment)\n",
    "\n",
    "1. **지식 증류 시나리오**: 여러분이 매우 정확하지만, 너무 크고 느려서 모바일 앱에 탑재할 수 없는 이미지 분류 모델(선생님 모델)을 가지고 있다고 가정해 보세요. 이 지식을 가볍고 빠른 MobileNetV2(학생 모델)에 전달하는 '지식 증류' 학습 과정을 단계별로 설명해 보세요.\n",
    "2. **벤치마킹 계획 수립**: \"실시간 동영상 배경 제거 API\"를 개발해야 하는 상황입니다. 모델 최적화 전후 성능을 비교하기 위한 벤치마킹 계획을 수립하세요. (측정할 핵심 지표, 사용할 도구, 테스트 시나리오 포함)\n",
    "3. **Triton `config.pbtxt` 작성**: `ResNet-50` PyTorch 모델을 Triton 서버에 배포하려고 합니다. 이 모델은 224x224 크기의 3채널 이미지(`FP32` 타입)를 입력받아, 1000개의 클래스에 대한 로짓(`FP32` 타입)을 출력합니다. 이 모델을 위한 최소한의 `config.pbtxt` 파일을 작성해보세요.\n",
    "\n",
    "---\n",
    "\n",
    "## 12. 되짚어보기 (Summary)\n",
    "\n",
    "이번 파트에서는 대규모 AI 모델을 다루기 위한 분산 학습, 모델 경량화, 고성능 서빙 기술들을 학습했습니다. FSDP와 DeepSpeed를 통해 단일 GPU의 한계를 넘어 거대한 모델을 효율적으로 학습시키는 방법을 알아보았고, 양자화, 가지치기, 지식 증류와 같은 경량화 기법으로 모델의 서빙 효율을 높이는 전략을 배웠습니다. 마지막으로, Triton과 TorchServe 같은 전문 추론 서버를 활용하여 프로덕션 환경에서 모델을 안정적이고 빠르게 서빙하는 방법을 살펴보았습니다. 이 모든 기술은 제한된 리소스 안에서 AI의 가능성을 최대로 끌어내기 위한 핵심적인 도구입니다.\n",
    "\n",
    "---\n",
    "\n",
    "## 13. 더 깊이 알아보기 (Further Reading)\n",
    "\n",
    "- [PyTorch FSDP 공식 튜토리얼](https://pytorch.org/tutorials/intermediate/FSDP_tutorial.html)\n",
    "- [DeepSpeed 공식 튜토리얼](https://www.deepspeed.ai/tutorials/)\n",
    "- [NVIDIA Triton Inference Server 공식 문서](https://developer.nvidia.com/triton-inference-server)\n",
    "- [PyTorch Quantization 공식 문서](https://pytorch.org/docs/stable/quantization.html)\n",
    "\n",
    "---\n",
    "\n",
    "**➡️ 다음 시간: [Part 13: 생성형 AI 및 AI 에이전트 심화](../13_generative_ai/part_13_generative_ai.md)**\n",
    "\n",
    "### 참고 자료\n",
    "\n",
    "*   [Hugging Face Optimum](https://huggingface.co/docs/optimum/index): 다양한 하드웨어 가속기에서 트랜스포머 모델을 효율적으로 학습하고 추론하기 위한 라이브러리\n",
    "*   [NVIDIA TensorRT](https://developer.nvidia.com/tensorrt): NVIDIA GPU에서 딥러닝 추론 성능을 극대화하기 위한 SDK\n",
    "\n",
    "---\n",
    "\n",
    "### ⚠️ What Could Go Wrong? (토론 주제)\n",
    "\n",
    "모델 최적화는 단순히 모델을 작고 빠르게 만드는 기술을 넘어, 비즈니스 목표와 긴밀하게 연결된 복잡한 트레이드오프 과정입니다.\n",
    "\n",
    "1.  **성능과 정확도의 트레이드오프 실패 (Failure in Performance-Accuracy Trade-off)**\n",
    "    *   모델을 경량화(양자화, 가지치기)하여 서빙 지연 시간(Latency)을 줄이는 데만 집중하다가, 비즈니스 핵심 지표(예: 추천 시스템의 클릭률, 사기 탐지 모델의 재현율)에 심각한 영향을 미칠 정도로 모델 정확도가 떨어지는 경우가 있습니다.\n",
    "    *   '이 정도 정확도 하락은 괜찮다'와 '이 정도 속도 향상은 의미 있다'의 기준은 어떻게 설정해야 할까요? 이 트레이드오프를 검증하기 위해 어떤 A/B 테스트를 설계해야 할까요?\n",
    "\n",
    "2.  **벤치마크 환경의 함정 (The Pitfall of the Benchmarking Environment)**\n",
    "    *   내 로컬 개발 장비(예: 고성능 GPU)에서 측정한 \"10배 성능 향상!\"이라는 결과가, 실제 프로덕션 환경(예: CPU 기반의 오토스케일링 인스턴스, 수많은 동시 요청이 몰리는 상황)에서는 전혀 재현되지 않는 경우가 많습니다.\n",
    "    *   신뢰할 수 있는 성능 벤치마킹을 위해, 테스트 환경이 실제 서빙 환경의 어떤 특성(예: 하드웨어, 배치 사이즈, 동시성)을 반영해야 할까요?\n",
    "\n",
    "3.  **특정 하드웨어에 대한 과잉 최적화 (Over-optimization for Specific Hardware)**\n",
    "    *   NVIDIA의 TensorRT나 AWS의 Inferentia와 같이 특정 벤더의 하드웨어와 라이브러리에 맞춰 모델을 깊게 최적화하면, 다른 종류의 하드웨어(예: 다른 클라우드, 온프레미스 서버, 엣지 디바이스)에서는 모델을 실행할 수 없거나 성능이 오히려 떨어지는 '벤더 종속성' 문제가 발생합니다.\n",
    "    *   이식성(Portability)을 유지하면서 성능을 최적화할 수 있는 중간 지점(예: ONNX)은 어디이며, 어떤 장단점을 가질까요?\n",
    "\n",
    "4.  **복잡성 증가로 인한 유지보수 비용 (Increased Maintenance Cost due to Complexity)**\n",
    "    *   원본 FP32 모델뿐만 아니라, 양자화된 INT8 모델, 프루닝된 모델, ONNX 변환 모델 등 관리해야 할 모델 아티팩트가 여러 개로 늘어납니다. 이로 인해 MLOps 파이프라인이 훨씬 복잡해지고, 디버깅 및 유지보수 비용이 증가합니다.\n",
    "    *   모델 최적화가 오히려 전체 시스템의 안정성을 해치고 기술 부채를 늘리는 상황을 어떻게 피할 수 있을까요?\n",
    "\n",
    "5.  **\"최적화는 필요 없다\"는 착각 (The Illusion that \"Optimization is Not Needed\")**\n",
    "    *   \"요즘 하드웨어는 워낙 좋고 클라우드는 무한 확장 가능하니, 모델 최적화에 드는 노력보다 그냥 더 좋은 인스턴스를 쓰는 게 낫다\"는 주장이 있습니다. 이 주장의 맹점은 무엇일까요?\n",
    "    *   모델 최적화가 단순히 '속도 개선'을 넘어, '서빙 비용 절감', '전력 효율성 증대(ESG)', '온디바이스(On-device) AI 구현' 등 더 넓은 비즈니스 가치를 가질 수 있다는 점을 어떻게 설득할 수 있을까요? "
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 5
}
