codebuff-agent 2.1.74__py3-none-any.whl

jupyter_ext/agent/skills/model_training.md

@@ -0,0 +1,318 @@
+---
+name: model-training
+description: 모델 훈련 최적화. GPU/CUDA로 모델을 훈련하거나 GPU 메모리 부족, 훈련 속도 개선 시 사용. mixed precision(fp16/bf16), gradient checkpointing, batch size 튜닝, optimizer 최적화 제공.
+---
+
+# Model Training Optimization Guide
+
+GPU/CPU 환경에서 효율적인 모델 훈련 방법을 안내합니다.
+
+## Resource Tiers
+
+### TIER_SMALL: GPU < 8GB 또는 CPU only
+- batch_size: 4-16
+- gradient_checkpointing: 필수
+- mixed precision: 권장
+- optimizer: 8-bit Adam
+
+### TIER_MEDIUM: GPU 8-24GB (RTX 3090, T4, A10)
+- batch_size: 16-64
+- gradient_checkpointing: 선택
+- mixed precision: fp16/bf16 필수
+- optimizer: AdamW 또는 8-bit Adam
+
+### TIER_LARGE: GPU > 24GB (A100, H100)
+- batch_size: 64-256
+- gradient_checkpointing: 불필요
+- mixed precision: bf16 권장
+- optimizer: AdamW, CUDA Graphs 활용
+
+---
+
+## 1. Mixed Precision Training
+
+### PyTorch Native (권장)
+```python
+import torch
+from torch.cuda.amp import autocast, GradScaler
+
+model = model.cuda()
+optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4)
+scaler = GradScaler()
+
+for batch in dataloader:
+    optimizer.zero_grad()
+
+    # Mixed precision forward pass
+    with autocast():
+        outputs = model(batch["input_ids"].cuda())
+        loss = criterion(outputs, batch["labels"].cuda())
+
+    # Scaled backward pass
+    scaler.scale(loss).backward()
+    scaler.step(optimizer)
+    scaler.update()
+```
+
+### Hugging Face Transformers
+```python
+from transformers import TrainingArguments, Trainer
+
+training_args = TrainingArguments(
+    output_dir="./results",
+    per_device_train_batch_size=16,
+
+    # Mixed Precision 선택 (GPU 아키텍처에 따라)
+    fp16=True,   # Volta, Turing, Ampere
+    # bf16=True,  # Ampere 이상 권장 (더 안정적)
+)
+```
+
+### Data Type 선택 가이드
+
+| GPU Architecture | Recommended | Notes |
+|------------------|-------------|-------|
+| Volta (V100) | fp16 | bf16 미지원 |
+| Turing (RTX 20xx, T4) | fp16 | bf16 미지원 |
+| Ampere (A100, RTX 30xx) | bf16 | fp16도 가능, bf16이 더 안정적 |
+| Hopper (H100) | bf16 | FP8도 지원 |
+
+---
+
+## 2. Gradient Checkpointing
+
+메모리 50-80% 절약, 훈련 속도 20-30% 감소 트레이드오프.
+
+### PyTorch
+```python
+from torch.utils.checkpoint import checkpoint_sequential
+
+# 모델 레이어를 청크로 나누어 체크포인팅
+model = nn.Sequential(layer1, layer2, layer3, layer4)
+output = checkpoint_sequential(model, 2, input)  # 2개 청크로 분할
+```
+
+### Hugging Face Transformers
+```python
+from transformers import TrainingArguments
+
+training_args = TrainingArguments(
+    output_dir="./results",
+    per_device_train_batch_size=4,
+    gradient_checkpointing=True,  # 활성화
+    gradient_accumulation_steps=16,  # effective batch = 4 * 16 = 64
+)
+```
+
+### 언제 사용?
+- GPU 메모리 부족 (OOM)
+- 큰 모델 (7B+ 파라미터)
+- 작은 GPU (< 16GB)
+
+---
+
+## 3. Batch Size & Gradient Accumulation
+
+### 최적 Batch Size 찾기
+```python
+# 1. 최대 batch size 찾기 (OOM 직전까지)
+# 2. 2의 거듭제곱 사용 (8, 16, 32, 64, 128)
+# 3. fp16: 8의 배수, A100: 64의 배수
+
+# Gradient Accumulation으로 effective batch size 확보
+training_args = TrainingArguments(
+    per_device_train_batch_size=4,      # GPU에 맞는 최대값
+    gradient_accumulation_steps=16,      # 4 * 16 = 64 effective
+)
+```
+
+### Batch Size 권장표
+
+| GPU Memory | Max Batch (fp32) | Max Batch (fp16) | Recommended |
+|------------|------------------|------------------|-------------|
+| 8GB | 4-8 | 8-16 | 8 (fp16) |
+| 16GB | 8-16 | 16-32 | 16 (fp16) |
+| 24GB | 16-32 | 32-64 | 32 (fp16) |
+| 40GB+ | 32-64 | 64-128 | 64 (bf16) |
+
+---
+
+## 4. Optimizer 최적화
+
+### 8-bit Adam (메모리 절약)
+```python
+# bitsandbytes 설치 필요: pip install bitsandbytes
+import bitsandbytes as bnb
+
+optimizer = bnb.optim.Adam8bit(
+    model.parameters(),
+    lr=1e-4,
+    betas=(0.9, 0.999)
+)
+
+# Hugging Face
+training_args = TrainingArguments(
+    optim="adamw_bnb_8bit",  # 8-bit AdamW
+)
+```
+
+### Adafactor (대용량 모델용)
+```python
+from transformers import Adafactor
+
+optimizer = Adafactor(
+    model.parameters(),
+    scale_parameter=True,
+    relative_step=True,
+    warmup_init=True,
+    lr=None  # relative_step=True면 자동 조절
+)
+```
+
+---
+
+## 5. Data Loading 최적화
+
+```python
+from torch.utils.data import DataLoader
+
+dataloader = DataLoader(
+    dataset,
+    batch_size=32,
+    shuffle=True,
+    num_workers=4,           # CPU 코어 수에 맞게
+    pin_memory=True,         # GPU 전송 가속
+    prefetch_factor=2,       # 미리 로드할 배치 수
+    persistent_workers=True  # 워커 재사용
+)
+
+# Hugging Face
+training_args = TrainingArguments(
+    dataloader_pin_memory=True,
+    dataloader_num_workers=4,
+)
+```
+
+---
+
+## 6. torch.compile (PyTorch 2.0+)
+
+```python
+import torch
+
+# 모델 컴파일 (최대 2x 속도 향상)
+model = torch.compile(model, mode="reduce-overhead")
+
+# Hugging Face
+training_args = TrainingArguments(
+    torch_compile=True,
+    torch_compile_backend="inductor",  # 기본값, 최적
+)
+```
+
+### 컴파일 모드
+
+| Mode | Speed | Memory | Use Case |
+|------|-------|--------|----------|
+| default | Good | Neutral | 일반적인 경우 |
+| reduce-overhead | Best | Slight increase | 긴 훈련 |
+| max-autotune | Best | Neutral | 시간 여유 있을 때 |
+
+---
+
+## 7. sklearn 모델 최적화
+
+### CPU 병렬화
+```python
+from sklearn.ensemble import RandomForestClassifier
+
+# n_jobs=-1: 모든 CPU 코어 사용
+model = RandomForestClassifier(
+    n_estimators=100,
+    n_jobs=-1,  # 병렬 처리
+    random_state=42
+)
+
+# GridSearchCV도 병렬화
+from sklearn.model_selection import GridSearchCV
+grid_search = GridSearchCV(
+    model, param_grid,
+    cv=5,
+    n_jobs=-1  # 병렬 교차 검증
+)
+```
+
+### 점진적 학습 (대용량 데이터)
+```python
+from sklearn.linear_model import SGDClassifier
+
+model = SGDClassifier(warm_start=True)
+
+# 청크별 학습
+for chunk in pd.read_csv("large_data.csv", chunksize=10000):
+    X, y = chunk.drop("target", axis=1), chunk["target"]
+    model.partial_fit(X, y, classes=[0, 1])
+```
+
+---
+
+## 8. 메모리 모니터링
+
+```python
+import torch
+
+# GPU 메모리 확인
+print(f"Allocated: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")
+print(f"Cached: {torch.cuda.memory_reserved() / 1024**3:.2f} GB")
+
+# 메모리 정리
+torch.cuda.empty_cache()
+
+# 훈련 중 주기적 정리 (Hugging Face)
+training_args = TrainingArguments(
+    torch_empty_cache_steps=4,  # 4스텝마다 캐시 정리
+)
+```
+
+---
+
+## Quick Reference: 최적 설정 조합
+
+### TIER_SMALL (GPU < 8GB)
+```python
+TrainingArguments(
+    per_device_train_batch_size=4,
+    gradient_accumulation_steps=16,
+    gradient_checkpointing=True,
+    fp16=True,
+    optim="adamw_bnb_8bit",
+    dataloader_num_workers=2,
+)
+```
+
+### TIER_MEDIUM (GPU 8-24GB)
+```python
+TrainingArguments(
+    per_device_train_batch_size=16,
+    gradient_accumulation_steps=4,
+    bf16=True,  # or fp16
+    optim="adamw_torch",
+    dataloader_pin_memory=True,
+    dataloader_num_workers=4,
+    torch_compile=True,
+)
+```
+
+### TIER_LARGE (GPU > 24GB)
+```python
+TrainingArguments(
+    per_device_train_batch_size=64,
+    bf16=True,
+    optim="adamw_torch",
+    dataloader_pin_memory=True,
+    dataloader_num_workers=8,
+    torch_compile=True,
+    torch_compile_backend="inductor",
+)
+```
+

jupyter_ext/agent/skills/pyspark.md

@@ -0,0 +1,352 @@
+---
+name: pyspark
+description: PySpark 성능 최적화. PySpark·분산 처리 코드를 쓰거나 대용량 데이터 처리 시 셔플링, 메모리 부족, 느린 조인 문제 해결. 파티셔닝, 캐싱, 브로드캐스트 조인, AQE 최적화 제공.
+---
+
+# PySpark Optimization Guide
+
+대용량 데이터 처리 시 PySpark 성능을 최적화하는 방법을 안내합니다.
+
+## Resource Tiers
+
+### TIER_SMALL: 데이터 < 10GB, 단일 노드
+- 기본 설정으로 충분
+- 파티션 수: 코어 수 × 2-4
+- 캐싱 선택적
+
+### TIER_MEDIUM: 데이터 10GB-100GB
+- 파티셔닝 최적화 필수
+- 브로드캐스트 조인 활용
+- AQE 활성화
+
+### TIER_LARGE: 데이터 > 100GB
+- 파티션 튜닝 필수
+- 데이터 스큐 처리
+- 파일 포맷 최적화 (Parquet)
+
+---
+
+## 1. 파티셔닝 최적화
+
+### 파티션 수 가이드라인
+```python
+# 권장: 클러스터 코어 수 × 4
+# 상한선: 작업당 100ms+ 소요되도록
+
+# 파티션 수 확인
+print(f"파티션 수: {df.rdd.getNumPartitions()}")
+
+# 파티션 수 조정
+# repartition: 셔플 발생 (증가/감소 모두 가능)
+df = df.repartition(200)
+
+# coalesce: 셔플 없음 (감소만 가능, 더 효율적)
+df = df.coalesce(100)
+```
+
+### 조인 키 기반 파티셔닝
+```python
+# 조인 전 같은 키로 파티셔닝 → 셔플 최소화
+users = users.repartition("user_id")
+orders = orders.repartition("user_id")
+
+# 여러 번 조인할 경우 캐싱
+users = users.repartition("user_id").cache()
+orders = orders.repartition("user_id").cache()
+
+# 조인 (동일 파티션 키 → 로컬 조인)
+result = users.join(orders, "user_id")
+```
+
+### 파티션 크기 권장
+| 파티션당 크기 | 상태 | 조치 |
+|--------------|------|------|
+| < 10MB | 너무 작음 | coalesce로 감소 |
+| 10MB-200MB | 적정 | 유지 |
+| > 200MB | 너무 큼 | repartition으로 증가 |
+
+---
+
+## 2. 캐싱 전략
+
+### 캐싱이 효과적인 경우
+```python
+# ✅ 여러 번 사용되는 DataFrame
+df = spark.read.parquet("data.parquet")
+df = df.filter(df.status == "active")
+df.cache()  # 또는 df.persist()
+
+# 첫 번째 사용
+count1 = df.count()
+
+# 두 번째 사용 (캐시에서 읽음 - 빠름)
+count2 = df.groupBy("category").count().collect()
+
+# 사용 후 해제
+df.unpersist()
+```
+
+### 캐싱이 불필요한 경우
+```python
+# ❌ 한 번만 사용되는 DataFrame
+df = spark.read.parquet("data.parquet")
+result = df.filter(...).groupBy(...).count()  # 캐싱 불필요
+```
+
+### 스토리지 레벨 선택
+```python
+from pyspark import StorageLevel
+
+# MEMORY_ONLY (기본값) - 메모리에만 저장
+df.cache()  # = df.persist(StorageLevel.MEMORY_ONLY)
+
+# MEMORY_AND_DISK - 메모리 부족 시 디스크 사용
+df.persist(StorageLevel.MEMORY_AND_DISK)
+
+# DISK_ONLY - 디스크에만 저장 (메모리 부족 시)
+df.persist(StorageLevel.DISK_ONLY)
+
+# MEMORY_ONLY_SER - 직렬화하여 메모리 절약
+df.persist(StorageLevel.MEMORY_ONLY_SER)
+```
+
+### 스토리지 레벨 가이드
+| 레벨 | 메모리 | 속도 | 사용 시기 |
+|------|--------|------|----------|
+| MEMORY_ONLY | 높음 | 가장 빠름 | 메모리 여유 있을 때 |
+| MEMORY_AND_DISK | 중간 | 빠름 | 대부분의 경우 권장 |
+| MEMORY_ONLY_SER | 낮음 | 중간 | 메모리 절약 필요 시 |
+| DISK_ONLY | 없음 | 느림 | 메모리 매우 부족 시 |
+
+---
+
+## 3. 브로드캐스트 조인
+
+### 작은 테이블 브로드캐스트
+```python
+from pyspark.sql.functions import broadcast
+
+# 작은 테이블을 모든 노드에 복사 → 셔플 제거
+small_df = spark.read.parquet("lookup_table.parquet")  # < 100MB
+large_df = spark.read.parquet("transactions.parquet")  # 수 GB
+
+# 명시적 브로드캐스트
+result = large_df.join(broadcast(small_df), "key")
+```
+
+### SQL 힌트 사용
+```python
+# SQL에서 브로드캐스트 힌트
+spark.sql("""
+    SELECT /*+ BROADCAST(small_table) */
+        l.*, s.name
+    FROM large_table l
+    JOIN small_table s ON l.key = s.key
+""")
+```
+
+### 브로드캐스트 임계값 설정
+```python
+# 기본값: 10MB
+# 자동 브로드캐스트 크기 조정
+spark.conf.set("spark.sql.autoBroadcastJoinThreshold", "100m")  # 100MB로 증가
+
+# 비활성화 (대형 테이블 실수로 브로드캐스트 방지)
+spark.conf.set("spark.sql.autoBroadcastJoinThreshold", "-1")
+```
+
+### 브로드캐스트 주의사항
+| 테이블 크기 | 브로드캐스트 | 권장 |
+|------------|-------------|------|
+| < 10MB | ✅ 안전 | 자동 적용 |
+| 10MB-100MB | ⚠️ 주의 | 명시적 사용 |
+| > 100MB | ❌ 위험 | 사용 금지 (OOM) |
+
+---
+
+## 4. Adaptive Query Execution (AQE)
+
+### AQE 활성화 (Spark 3.0+)
+```python
+# AQE 활성화 (Spark 3.2+ 기본값)
+spark.conf.set("spark.sql.adaptive.enabled", "true")
+
+# 자동 파티션 병합
+spark.conf.set("spark.sql.adaptive.coalescePartitions.enabled", "true")
+
+# 자동 스큐 조인 최적화
+spark.conf.set("spark.sql.adaptive.skewJoin.enabled", "true")
+
+# 자동 브로드캐스트 조인 전환
+spark.conf.set("spark.sql.adaptive.localShuffleReader.enabled", "true")
+```
+
+### AQE 효과
+- 런타임에 조인 전략 자동 선택
+- 작은 테이블 감지 시 브로드캐스트로 전환
+- 셔플 파티션 자동 병합
+- 데이터 스큐 자동 처리
+
+---
+
+## 5. 데이터 스큐 처리
+
+### 스큐 감지
+```python
+# 파티션별 레코드 수 확인
+from pyspark.sql.functions import spark_partition_id
+
+df.groupBy(spark_partition_id()).count().show()
+
+# 키별 분포 확인
+df.groupBy("join_key").count().orderBy("count", ascending=False).show(10)
+```
+
+### 솔팅 (Salting) 기법
+```python
+from pyspark.sql.functions import concat, lit, rand, floor
+
+# 스큐된 키에 솔트 추가
+SALT_BUCKETS = 10
+
+# 큰 테이블: 랜덤 솔트 추가
+large_df = large_df.withColumn(
+    "salted_key",
+    concat(df["key"], lit("_"), floor(rand() * SALT_BUCKETS).cast("string"))
+)
+
+# 작은 테이블: 모든 솔트 값으로 복제
+from pyspark.sql.functions import explode, array
+
+small_df = small_df.withColumn(
+    "salt",
+    explode(array([lit(str(i)) for i in range(SALT_BUCKETS)]))
+)
+small_df = small_df.withColumn(
+    "salted_key",
+    concat(df["key"], lit("_"), df["salt"])
+)
+
+# 솔티드 키로 조인
+result = large_df.join(small_df, "salted_key")
+```
+
+---
+
+## 6. 파일 포맷 최적화
+
+### Parquet 사용 (권장)
+```python
+# CSV → Parquet 변환 (최초 1회)
+df = spark.read.csv("data.csv", header=True, inferSchema=True)
+df.write.parquet("data.parquet")
+
+# Parquet 읽기 (빠름)
+df = spark.read.parquet("data.parquet")
+```
+
+### 파일 포맷 비교
+| 포맷 | 읽기 속도 | 쓰기 속도 | 압축률 | 컬럼 선택 |
+|------|----------|----------|--------|----------|
+| CSV | 느림 | 느림 | 없음 | ❌ |
+| JSON | 느림 | 느림 | 없음 | ❌ |
+| Parquet | 빠름 | 빠름 | 높음 | ✅ |
+| ORC | 빠름 | 빠름 | 높음 | ✅ |
+
+### 컬럼 선택 (Predicate Pushdown)
+```python
+# ✅ 필요한 컬럼만 선택 (Parquet에서 효율적)
+df = spark.read.parquet("data.parquet").select("col1", "col2", "col3")
+
+# ✅ 필터 먼저 적용 (Predicate Pushdown)
+df = spark.read.parquet("data.parquet").filter("date > '2024-01-01'")
+```
+
+---
+
+## 7. 조인 전 필터링
+
+### 조인 전 데이터 축소
+```python
+# ❌ 나쁜 예: 조인 후 필터
+result = large_df.join(other_df, "key").filter("status = 'active'")
+
+# ✅ 좋은 예: 조인 전 필터
+filtered = large_df.filter("status = 'active'")
+result = filtered.join(other_df, "key")
+```
+
+### 불필요한 컬럼 제거
+```python
+# ❌ 나쁜 예: 모든 컬럼 조인
+result = df1.join(df2, "key")
+
+# ✅ 좋은 예: 필요한 컬럼만 선택 후 조인
+df1_slim = df1.select("key", "needed_col1", "needed_col2")
+df2_slim = df2.select("key", "needed_col3")
+result = df1_slim.join(df2_slim, "key")
+```
+
+---
+
+## 8. 셔플 최적화
+
+### 셔플 파티션 수 조정
+```python
+# 기본값: 200
+# 데이터 크기에 따라 조정
+spark.conf.set("spark.sql.shuffle.partitions", "400")  # 대용량
+spark.conf.set("spark.sql.shuffle.partitions", "50")   # 소용량
+
+# AQE 사용 시 자동 조정됨 (권장)
+spark.conf.set("spark.sql.adaptive.enabled", "true")
+spark.conf.set("spark.sql.adaptive.coalescePartitions.enabled", "true")
+```
+
+### 셔플 줄이기
+```python
+# ❌ 셔플 발생: 여러 번 groupBy
+df.groupBy("col1").agg({"val": "sum"})
+df.groupBy("col1").agg({"val": "avg"})
+
+# ✅ 셔플 1회: 한 번에 집계
+from pyspark.sql.functions import sum, avg
+
+df.groupBy("col1").agg(
+    sum("val").alias("sum_val"),
+    avg("val").alias("avg_val")
+)
+```
+
+---
+
+## Quick Reference: 최적화 체크리스트
+
+```python
+# 1. AQE 활성화 (Spark 3.0+)
+spark.conf.set("spark.sql.adaptive.enabled", "true")
+
+# 2. Parquet 사용
+df = spark.read.parquet("data.parquet")
+
+# 3. 조인 전 필터링
+df = df.filter(...).select(["필요한", "컬럼만"])
+
+# 4. 브로드캐스트 조인 (작은 테이블)
+result = large_df.join(broadcast(small_df), "key")
+
+# 5. 반복 사용 DataFrame 캐싱
+df = df.repartition("join_key").cache()
+
+# 6. 셔플 파티션 조정
+spark.conf.set("spark.sql.shuffle.partitions", "200")
+```
+
+### 조인 전략 선택 가이드
+| 상황 | 조인 전략 | 설정 |
+|------|----------|------|
+| 작은 테이블 (< 100MB) | 브로드캐스트 | `broadcast(df)` |
+| 같은 키로 파티셔닝됨 | 소트 머지 | 기본 |
+| 데이터 스큐 있음 | 솔팅 + AQE | `skewJoin.enabled` |
+| 대용량 + 대용량 | 소트 머지 + AQE | 기본 |
+

jupyter_ext/agent/skills/python_code_quality.md

@@ -0,0 +1,35 @@
+---
+name: python_code_quality
+description: Python 코드를 쓸 때(데이터 분석·시각화·파일 처리·노트북 셀) 먼저 읽는다. 보안(SQL 파라미터 바인딩·민감 정보·PII 마스킹)·성능(dtypes·usecols·벡터 연산)·코드 품질 원칙과 파일 경로 확인 규칙.
+---
+
+# 코드 생성 품질 원칙 (기본 적용)
+생성하는 모든 코드에 아래 원칙을 반영하세요. 코드리뷰에서 지적될 패턴을 처음부터 방지합니다.
+
+## 🛡️ 보안 (금융권 기준)
+- SQL 쿼리: 파라미터 바인딩 필수 (f-string 직접 삽입 금지)
+- 파일 경로: os.path.join() 또는 pathlib 사용 (경로 조작 방지)
+- 민감 정보(API 키, 비밀번호, 접속정보): os.environ.get()으로 처리 (하드코딩 금지)
+- DataFrame에 PII 컬럼(주민번호, 계좌번호, 전화번호 등) 존재 시: 마스킹 처리 코드 포함
+- 로깅/출력에 민감 데이터 노출 금지
+
+## ⚡ 성능 (인프라 인지형)
+- DataFrame: dtypes 최적화 (object→category, int64→int32 등), 불필요한 .copy() 제거
+- 파일 읽기: usecols로 필요 컬럼만 지정, 대용량 시 chunksize 적용
+- 반복 연산: 벡터 연산 우선 (iterrows/itertuples 대신 apply/vectorized ops)
+- 중복 연산 제거: 동일 계산 결과는 변수에 저장 후 재사용
+
+## 🔧 코드 품질
+- 매직 넘버 대신 상단에 명명 상수 정의
+- 에러 가능성 높은 I/O(파일 읽기, API 호출)는 try-except로 감싸고 의미 있는 에러 메시지 출력
+- 반복 사용되는 로직은 함수로 분리 (재현성 확보)
+- 데이터 검증: 처리 전 shape/dtypes/null 비율 확인 코드 포함
+
+## 📁 파일 경로
+- 파일 경로가 주어지지 않았으면 os.getcwd()로 현재 디렉토리를 확인하는 코드를 먼저 포함하세요.
+- 파일을 열기 전에 os.path.isfile()로 존재 여부를 확인하고, 없으면 glob으로 검색하는 fallback 코드를 포함하세요.
+
+## 📊 그 밖의 규칙
+- Use English labels for plots (required for Korean text rendering issues)
+- Handle large datasets efficiently (use chunking, sampling when needed)
+- Include error handling for file operations

jupyter_ext/agent/skills/regression_evaluation.md

@@ -0,0 +1,12 @@
+---
+name: regression_evaluation
+description: 'Regression Evaluation Template. 이런 요청에 쓴다: regression, rmse, mae, r2 score, 회귀, 잔차'
+---
+## Regression Evaluation Template
+1. **Predictions**: `y_pred = model.predict(X_test)`
+2. **Metrics**: RMSE, MAE, R², MAPE — `mean_squared_error()`, `mean_absolute_error()`, `r2_score()`
+3. **Residual Plot**: `residuals = y_test - y_pred` → scatter plot vs predicted
+4. **Residual Distribution**: Histogram / Q-Q plot for normality check
+5. **Actual vs Predicted**: 45-degree line scatter plot
+6. **Cross-Validation**: `cross_val_score(scoring='neg_root_mean_squared_error')`
+7. **Feature Coefficients**: For linear models, inspect `model.coef_`