# Python 3.11+ 필요
python3 --version

# 가상 환경 생성
python3 -m venv venv
source venv/bin/activate

# 레포지토리 클론
git clone https://github.com/rohitg00/ai-engineering-from-scratch.git
cd ai-engineering-from-scratch
pip install -r requirements.txt

# Claude Code
# 커리큘럼 스킬을 에이전트에 로드

# Cursor
git clone https://github.com/rohitg00/ai-engineering-from-scratch.git

docker build -t ai-engineering .
docker run -it ai-engineering

# models/predictor.py
import joblib
import numpy as np
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI(title="AI Prediction Service")

# 모델 로드
model = joblib.load("models/trained_model.pkl")
tokenizer = joblib.load("models/tokenizer.pkl")

class PredictionRequest(BaseModel):
    text: str
    temperature: float = 0.7
    top_k: int = 50

class PredictionResponse(BaseModel):
    prediction: str
    confidence: float
    tokens: list[str]

@app.post("/predict", response_model=PredictionResponse)
def predict(request: PredictionRequest):
    """단일 텍스트 예측 엔드포인트"""
    try:
        encoded = tokenizer.encode_plus(
            request.text,
            return_tensors="np",
            padding="max_length",
            max_length=512,
            truncation=True
        )
        
        input_ids = np.array(encoded["input_ids"])
        attention_mask = np.array(encoded["attention_mask"])
        
        prediction = model.predict(input_ids, attention_mask)
        confidence = float(np.max(prediction))
        predicted_class = int(np.argmax(prediction))
        
        return PredictionResponse(
            prediction=str(predicted_class),
            confidence=confidence,
            tokens=[request.text[:20]]
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/health")
def health_check():
    """서비스 상태 확인 엔드포인트"""
    return {"status": "healthy", "model_version": "1.0.0"}

# Dockerfile
FROM python:3.12-slim

WORKDIR /app

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

# 애플리케이션 복사
COPY . .

# 모델 파일 복사
COPY models/ ./models/

EXPOSE 8000

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

docker build -t ai-service:v1 .
docker run -p 8000:8000 -v $(pwd)/models:/app/models ai-service:v1

# k8s/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ai-prediction-service
  labels:
    app: ai-prediction
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ai-prediction
  template:
    metadata:
      labels:
        app: ai-prediction
    spec:
      containers:
      - name: ai-service
        image: ai-service:v1
        ports:
        - containerPort: 8000
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1Gi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: ai-prediction-service
spec:
  selector:
    app: ai-prediction
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8000
  type: LoadBalancer

# .github/workflows/mlops.yml
name: MLOps Pipeline

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'
      
      - name: Install dependencies
        run: pip install -r requirements.txt
      
      - name: Run tests
        run: pytest tests/ -v --cov=models --cov-report=xml
      
      - name: Upload coverage
        uses: codecov/codecov-action@v4

  train:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Train model
        run: python scripts/train.py
      
      - name: Save model artifact
        uses: actions/upload-artifact@v4
        with:
          name: trained-model
          path: models/

  deploy:
    needs: train
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v4
      
      - name: Download model
        uses: actions/download-artifact@v4
        with:
          name: trained-model
          path: models/
      
      - name: Build and push Docker image
        run: |
          docker build -t ghcr.io/${{ github.repository }}/ai-service:${{ github.sha }} .
          echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u ${{ github.actor }} --password-stdin
          docker push ghcr.io/${{ github.repository }}/ai-service:${{ github.sha }}
      
      - name: Deploy to Kubernetes
        run: |
          kubectl set image deployment/ai-prediction-service \
            ai-service=ghcr.io/${{ github.repository }}/ai-service:${{ github.sha }}

import torch
import torch.nn as nn
import math

class MultiHeadAttention(nn.Module):
    """다중 헤드 어텐션 구현"""
    
    def __init__(self, d_model=512, n_heads=8):
        super().__init__()
        self.d_model = d_model
        self.n_heads = n_heads
        self.d_k = d_model // n_heads
        
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)
    
    def scaled_dot_product_attention(self, Q, K, V, mask=None):
        """스케일된 닷 프로덕트 어텐션"""
        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
        
        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)
        
        attention = torch.softmax(scores, dim=-1)
        return torch.matmul(attention, V), attention
    
    def forward(self, Q, K, V, mask=None):
        batch_size = Q.size(0)
        
        # 선형 변환 후 멀티헤드로 분할
        Q = self.W_q(Q).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)
        K = self.W_k(K).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)
        V = self.W_v(V).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)
        
        # 어텐션 계산
        attn_output, attention_weights = self.scaled_dot_product_attention(Q, K, V, mask)
        
        # 헤드를 다시 결합
        attn_output = attn_output.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model)
        
        return self.W_o(attn_output), attention_weights

class PositionalEncoding(nn.Module):
    """사인/코사인 위치 인코딩"""
    
    def __init__(self, d_model, max_len=5000, dropout=0.1):
        super().__init__()
        self.dropout = nn.Dropout(dropout)
        
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
        
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0)
        self.register_buffer('pe', pe)
    
    def forward(self, x):
        x = x + self.pe[:, :x.size(1), :]
        return self.dropout(x)

# benchmarking/model_benchmark.py
import time
import numpy as np
from sklearn.metrics import classification_report, confusion_matrix
import torch

class ModelBenchmark:
    """모델 성능 벤치마킹 클래스"""
    
    def __init__(self, model, tokenizer, device="cuda"):
        self.model = model
        self.tokenizer = tokenizer
        self.device = device
    
    def benchmark_accuracy(self, test_dataset):
        """정확도 벤치마크"""
        self.model.eval()
        correct = 0
        total = 0
        predictions = []
        true_labels = []
        
        with torch.no_grad():
            for texts, labels in test_dataset:
                inputs = self.tokenizer(
                    texts, return_tensors="pt", 
                    padding=True, truncation=True, max_length=512
                ).to(self.device)
                
                outputs = self.model(**inputs)
                preds = torch.argmax(outputs.logits, dim=1)
                
                correct += (preds == labels.to(self.device)).sum().item()
                total += labels.size(0)
                predictions.extend(preds.cpu().numpy())
                true_labels.extend(labels.numpy())
        
        accuracy = correct / total
        report = classification_report(true_labels, predictions, output_dict=True)
        
        return {
            "accuracy": accuracy,
            "classification_report": report,
            "confusion_matrix": confusion_matrix(true_labels, predictions).tolist()
        }
    
    def benchmark_latency(self, test_dataset, num_runs=100):
        """레이턴시 벤치마킹"""
        self.model.eval()
        latencies = []
        
        with torch.no_grad():
            for texts, _ in test_dataset:
                inputs = self.tokenizer(
                    texts, return_tensors="pt",
                    padding=True, truncation=True, max_length=512
                ).to(self.device)
                
                # Warm-up
                _ = self.model(**inputs)
                
                # Timing
                start = time.perf_counter()
                for _ in range(num_runs):
                    _ = self.model(**inputs)
                end = time.perf_counter()
                
                avg_latency = (end - start) / num_runs
                latencies.append(avg_latency)
        
        return {
            "avg_latency_ms": np.mean(latencies) * 1000,
            "p50_latency_ms": np.percentile(latencies, 50) * 1000,
            "p99_latency_ms": np.percentile(latencies, 99) * 1000,
            "throughput_rps": 1.0 / np.mean(latencies)
        }
    
    def full_report(self, test_dataset):
        """종합 벤치마크 리포트"""
        accuracy_report = self.benchmark_accuracy(test_dataset)
        latency_report = self.benchmark_latency(test_dataset)
        
        return {
            "accuracy": accuracy_report,
            "latency": latency_report,
            "summary": {
                "accuracy_pct": f"{accuracy_report['accuracy']*100:.2f}%",
                "avg_latency": f"{latency_report['avg_latency_ms']:.2f}ms",
                "throughput": f"{latency_report['throughput_rps']:.1f} req/s"
            }
        }

# finetuning/lora_finetune.py
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from transformers import AutoModelForCausalLM, BitsAndBytesConfig
import torch

def setup_lora_finetuning(model_name="meta-llama/Llama-3-8B"):
    """LoRA 파인튜닝 설정"""
    
    # 4비트 양자화 설정
    quant_config = BitsAndBytesConfig(
        load_in_4bit=True,
        bnb_4bit_quant_type="nf4",
        bnb_4bit_compute_dtype=torch.float16,
        bnb_4bit_use_double_quant=True
    )
    
    # 모델 로드 (양자화)
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        quantization_config=quant_config,
        device_map="auto"
    )
    
    # 모델 준비
    model = prepare_model_for_kbit_training(model)
    
    # LoRA 설정
    lora_config = LoraConfig(
        r=16,
        lora_alpha=32,
        target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
        lora_dropout=0.05,
        bias="none",
        task_type="CAUSAL_LM"
    )
    
    # LoRA 적용
    model = get_peft_model(model, lora_config)
    model.print_trainable_parameters()
    
    return model

def train_with_trainer(model, train_dataset, output_dir="./lora_output"):
    """Trainer로 파인튜닝 실행"""
    from transformers import TrainingArguments, Trainer
    
    training_args = TrainingArguments(
        output_dir=output_dir,
        per_device_train_batch_size=4,
        gradient_accumulation_steps=4,
        learning_rate=2e-4,
        fp16=True,
        logging_steps=10,
        save_strategy="epoch",
        eval_strategy="epoch",
        num_train_epochs=3,
        warmup_ratio=0.1,
        optim="paged_adamw_8bit"
    )
    
    trainer = Trainer(
        model=model,
        args=training_args,
        train_dataset=train_dataset
    )
    
    trainer.train()
    trainer.save_model(output_dir)
    return trainer