# Deployment Phi-3 en Kubernetes con autoscaling y GPU
apiVersion: apps/v1
kind: Deployment
metadata:
  name: phi3-inference
  namespace: ml-models
spec:
  replicas: 3  # Initial replicas
  selector:
    matchLabels:
      app: phi3-inference
  template:
    metadata:
      labels:
        app: phi3-inference
    spec:
      containers:
      - name: phi3-server
        image: phi3-inference:latest  # Tu imagen Docker con Phi-3
        ports:
        - containerPort: 8000
        resources:
          requests:
            memory: "8Gi"
            cpu: "2"
            nvidia.com/gpu: "1"  # 1x GPU T4/A10
          limits:
            memory: "16Gi"
            cpu: "4"
            nvidia.com/gpu: "1"
        env:
        - name: MODEL_PATH
          value: "/models/phi3-mini-4k-instruct-int4"
        - name: MAX_BATCH_SIZE
          value: "32"
        - name: WORKERS
          value: "4"
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 60
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 8000
          initialDelaySeconds: 30
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: phi3-service
  namespace: ml-models
spec:
  selector:
    app: phi3-inference
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8000
  type: LoadBalancer
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: phi3-hpa
  namespace: ml-models
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: phi3-inference
  minReplicas: 3
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 60
      policies:
      - type: Percent
        value: 50  # Scale up 50% at a time
        periodSeconds: 60
    scaleDown:
      stabilizationWindowSeconds: 300  # Wait 5min before scaling down
      policies:
      - type: Percent
        value: 25  # Scale down 25% at a time
        periodSeconds: 60
 

# Script benchmarking accuracy Phi-3 vs GPT-4 en queries FinTech
import pandas as pd
from transformers import AutoModelForCausalLM, AutoTokenizer
from openai import OpenAI
import time

# Cargar Phi-3-mini quantized INT4
model_phi3 = AutoModelForCausalLM.from_pretrained(
    "microsoft/Phi-3-mini-4k-instruct",
    device_map="cuda",
    torch_dtype="auto",
    trust_remote_code=True,
    load_in_4bit=True  # Quantization INT4 automática
)

tokenizer_phi3 = AutoTokenizer.from_pretrained("microsoft/Phi-3-mini-4k-instruct")

# Cliente OpenAI para GPT-4
client_openai = OpenAI(api_key="sk-...")

# Dataset: 1,000 queries reales low-complexity con ground truth
df_test = pd.read_csv("fintech_queries_test_1000.csv")  # Columnas: query, ground_truth_answer, complexity_level

results = []

for idx, row in df_test.iterrows():
    query = row['query']
    ground_truth = row['ground_truth_answer']
    
    # Inference Phi-3
    start_phi3 = time.time()
    messages_phi3 = [{"role": "user", "content": query}]
    inputs_phi3 = tokenizer_phi3.apply_chat_template(
        messages_phi3,
        add_generation_prompt=True,
        return_tensors="pt"
    ).to("cuda")
    
    outputs_phi3 = model_phi3.generate(
        inputs_phi3,
        max_new_tokens=512,
        temperature=0.1
    )
    
    response_phi3 = tokenizer_phi3.decode(
        outputs_phi3[0], 
        skip_special_tokens=True
    )
    latency_phi3 = (time.time() - start_phi3) * 1000  # ms
    
    # Inference GPT-4
    start_gpt4 = time.time()
    response_gpt4 = client_openai.chat.completions.create(
        model="gpt-4-turbo",
        messages=[{"role": "user", "content": query}],
        temperature=0.1,
        max_tokens=512
    )
    latency_gpt4 = (time.time() - start_gpt4) * 1000  # ms
    
    # Evaluar accuracy (comparar con ground truth usando similarity)
    # Aquí simplificado - en producción usar BERT-score o human eval
    accuracy_phi3 = 1 if ground_truth.lower() in response_phi3.lower() else 0
    accuracy_gpt4 = 1 if ground_truth.lower() in response_gpt4.choices[0].message.content.lower() else 0
    
    results.append({
        'query_id': idx,
        'complexity': row['complexity_level'],
        'accuracy_phi3': accuracy_phi3,
        'accuracy_gpt4': accuracy_gpt4,
        'latency_phi3_ms': latency_phi3,
        'latency_gpt4_ms': latency_gpt4
    })

# Análisis resultados
df_results = pd.DataFrame(results)

print("=== BENCHMARKING RESULTS ===")
print(f"Phi-3 Accuracy (low complexity): {df_results[df_results['complexity']=='low']['accuracy_phi3'].mean():.2%}")
print(f"GPT-4 Accuracy (low complexity): {df_results[df_results['complexity']=='low']['accuracy_gpt4'].mean():.2%}")
print(f"Phi-3 Latency p95 (ms): {df_results['latency_phi3_ms'].quantile(0.95):.0f}")
print(f"GPT-4 Latency p95 (ms): {df_results['latency_gpt4_ms'].quantile(0.95):.0f}")

# Output ejemplo:
# Phi-3 Accuracy (low complexity): 91%
# GPT-4 Accuracy (low complexity): 94%
# Phi-3 Latency p95 (ms): 120
# GPT-4 Latency p95 (ms): 1350

# Fine-tuning Phi-3-mini con QLoRA (eficiente en memoria)
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from datasets import load_dataset
import torch

# Cargar modelo base Phi-3-mini con quantization
model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Phi-3-mini-4k-instruct",
    torch_dtype=torch.bfloat16,
    device_map="auto",
    load_in_4bit=True,
    trust_remote_code=True
)

tokenizer = AutoTokenizer.from_pretrained("microsoft/Phi-3-mini-4k-instruct")
tokenizer.pad_token = tokenizer.eos_token

# Preparar para QLoRA training
model = prepare_model_for_kbit_training(model)

# Configurar LoRA adapters (solo entrenar 0.1% parámetros)
lora_config = LoraConfig(
    r=16,  # Rank LoRA matrices
    lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

model = get_peft_model(model, lora_config)

# Dataset: 5,000 queries FinTech con respuestas ground truth
dataset = load_dataset("csv", data_files="fintech_queries_train_5000.csv")

def format_prompts(examples):
    """Formatear queries en chat template Phi-3"""
    texts = []
    for query, answer in zip(examples['query'], examples['answer']):
        messages = [
            {"role": "user", "content": query},
            {"role": "assistant", "content": answer}
        ]
        text = tokenizer.apply_chat_template(messages, tokenize=False)
        texts.append(text)
    return {"text": texts}

dataset = dataset.map(format_prompts, batched=True)

# Training arguments
training_args = TrainingArguments(
    output_dir="./phi3-fintech-finetuned",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=8,
    learning_rate=2e-4,
    logging_steps=10,
    save_steps=100,
    save_total_limit=3,
    fp16=True,
    report_to="none"
)

# Entrenar
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset['train'],
    tokenizer=tokenizer
)

trainer.train()

# Guardar modelo fine-tuned
model.save_pretrained("./phi3-fintech-final")
tokenizer.save_pretrained("./phi3-fintech-final")

print("✅ Fine-tuning completado. Accuracy esperada: 93-94% (validar en test set)")

# Router hybrid LLM/SLM con clasificación de complejidad
from transformers import pipeline
from openai import OpenAI
import time

# Classifier complejidad (modelo lightweight entrenado en queries etiquetadas)
complexity_classifier = pipeline(
    "text-classification",
    model="fintech-complexity-classifier",  # Custom fine-tuned BERT
    device=0
)

# Cliente OpenAI para GPT-4
client_openai = OpenAI(api_key="sk-...")

def route_query(query: str, confidence_threshold: float = 0.7):
    """
    Clasifica query y rutea a Phi-3 (on-premise) o GPT-4 (API)
    Returns: tuple: (response, model_used, latency_ms, cost)
    """
    start_time = time.time()
    
    # Clasificar complejidad
    complexity_result = complexity_classifier(query)[0]
    complexity_score = complexity_result['score']
    complexity_label = complexity_result['label']  # 'LOW', 'MEDIUM', 'HIGH'
    
    # Decisión routing
    if complexity_label == 'LOW' and complexity_score > confidence_threshold:
        # Usar Phi-3 on-premise (90% queries)
        response = phi3_inference(query)
        model_used = "phi3-mini-fintech"
        cost = 0.0001  # Coste on-premise despreciable
        
    elif complexity_label == 'MEDIUM' and complexity_score > 0.8:
        # Intentar Phi-3 primero, fallback GPT-4 si confidence baja
        response_phi3, confidence_phi3 = phi3_inference_with_confidence(query)
        if confidence_phi3 > 0.75:
            response = response_phi3
            model_used = "phi3-mini-fintech"
            cost = 0.0001
        else:
            # Fallback a GPT-4
            response = gpt4_inference(query)
            model_used = "gpt-4-turbo-fallback"
            cost = calculate_gpt4_cost(query, response)
    else:
        # Queries complejas directo a GPT-4 (10% queries)
        response = gpt4_inference(query)
        model_used = "gpt-4-turbo"
        cost = calculate_gpt4_cost(query, response)
    
    latency_ms = (time.time() - start_time) * 1000
    
    # Logging para monitoring
    log_routing_decision(query, complexity_label, complexity_score, model_used, latency_ms, cost)
    
    return response, model_used, latency_ms, cost

def phi3_inference(query: str) -> str:
    """Inference Phi-3 on-premise (implementar según deployment)"""
    # Aquí integración con tu deployment Kubernetes/Docker de Phi-3
    pass

def phi3_inference_with_confidence(query: str):
    """Phi-3 con confidence score"""
    pass

def gpt4_inference(query: str) -> str:
    """Inference GPT-4 via API"""
    response = client_openai.chat.completions.create(
        model="gpt-4-turbo",
        messages=[{"role": "user", "content": query}],
        temperature=0.1
    )
    return response.choices[0].message.content

def calculate_gpt4_cost(query: str, response: str) -> float:
    """Calcular coste real GPT-4 (aprox)"""
    input_tokens = len(query.split()) * 1.3  # Estimación rough
    output_tokens = len(response.split()) * 1.3
    cost = (input_tokens / 1_000_000 * 5) + (output_tokens / 1_000_000 * 20)
    return cost

def log_routing_decision(query: str, complexity_label: str, complexity_score: float, 
                        model_used: str, latency_ms: float, cost: float):
    """Logging para monitoring"""
    print(f"ROUTING: {complexity_label}({complexity_score:.2f}) → {model_used} "
          f"({latency_ms:.0f}ms, ${cost:.4f})")

# Ejemplo uso
query_simple = "¿Cuál es mi saldo actual?"
response, model, latency, cost = route_query(query_simple)
print(f"Model: {model}, Latency: {latency:.0f}ms, Cost: ${cost:.4f}")
# Output: Model: phi3-mini-fintech, Latency: 95ms, Cost: $0.0001

query_complex = ("Quiero disputar 3 transacciones de los últimos 60 días que no reconozco, "
                "necesito análisis completo con recomendaciones legales")
response, model, latency, cost = route_query(query_complex)
print(f"Model: {model}, Latency: {latency:.0f}ms, Cost: ${cost:.4f}")
# Output: Model: gpt-4-turbo, Latency: 1420ms, Cost: $0.0350