# Calculadora TCO Cloud AI (AWS SageMaker / Azure ML)
def calculate_cloud_ai_cost(
    gpu_type="a100",
    hours_per_day=24,
    days_per_month=30,
    num_instances=1,
    data_transfer_tb_per_month=10
):
    """
    Calcula coste mensual cloud AI deployment.
    
    Args:
        gpu_type: "a100", "v100", "t4"
        hours_per_day: Horas operación daily (24 = continuous)
        days_per_month: Días operación mensual
        num_instances: Número de instances GPU
        data_transfer_tb_per_month: TB data transfer out (inference responses)
    
    Returns:
        total_monthly_cost: Coste mensual total
    """
    # Pricing AWS SageMaker (us-east-1, Enero 2025)
    gpu_pricing = {
        "a100": 5.12,  # ml.p4d.24xlarge (8x A100 40GB) = $40.96/hr ÷ 8
        "v100": 3.06,  # ml.p3.2xlarge (V100 16GB)
        "t4": 0.526    # ml.g4dn.xlarge (T4 16GB)
    }

    # Data transfer pricing (simplificado)
    data_transfer_cost_per_tb = 90  # AWS data transfer out promedio

    # Cálculo GPU compute
    hourly_rate = gpu_pricing[gpu_type]
    monthly_hours = hours_per_day * days_per_month
    compute_cost = hourly_rate * monthly_hours * num_instances

    # Data transfer cost
    transfer_cost = data_transfer_tb_per_month * data_transfer_cost_per_tb

    # Storage cost (modelo + logs) - estimado $100/mes
    storage_cost = 100

    total_monthly_cost = compute_cost + transfer_cost + storage_cost

    return {
        "compute_cost": compute_cost,
        "transfer_cost": transfer_cost,
        "storage_cost": storage_cost,
        "total_monthly": total_monthly_cost,
        "total_annual": total_monthly_cost * 12
    }


# Escenario real: Startup SaaS con inference continua
scenario_1 = calculate_cloud_ai_cost(
    gpu_type="a100",
    hours_per_day=24,
    days_per_month=30,
    num_instances=1,
    data_transfer_tb_per_month=10
)

print("CLOUD AI COST - Continuous Inference (A100 GPU):")
print(f" Compute cost: ${scenario_1['compute_cost']:,.0f}/mes")
print(f" Data transfer: ${scenario_1['transfer_cost']:,.0f}/mes")
print(f" Storage: ${scenario_1['storage_cost']:,.0f}/mes")
print(f" TOTAL MONTHLY: ${scenario_1['total_monthly']:,.0f}")
print(f" TOTAL ANNUAL: ${scenario_1['total_annual']:,.0f}")

# Output esperado:
# Compute cost: $3,686/mes (5.12 * 24 * 30)
# Data transfer: $900/mes
# Storage: $100/mes
# TOTAL MONTHLY: $4,686
# TOTAL ANNUAL: $56,232 ← Mayor que capex edge $250k spread over 3 años

 

#!/bin/bash
# Desplegar llama.cpp en Raspberry Pi 4/5 (ARM64) con modelo quantizado
# Tested: Raspberry Pi 5 8GB, Ubuntu 24.04 LTS

echo "Installing llama.cpp dependencies..."
sudo apt-get update
sudo apt-get install -y build-essential git cmake

# Clone llama.cpp repo oficial
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# Build para ARM (sin CUDA)
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
cmake --build . --config Release -j 4

# Descargar modelo Qwen 2.5-3B quantizado Q4_K_M (1.5GB)
cd ../models
wget https://huggingface.co/Qwen/Qwen2.5-3B-Instruct-GGUF/resolve/main/qwen2.5-3b-instruct-q4_k_m.gguf

# Benchmark inference
cd ..
./build/bin/llama-bench \
  -m models/qwen2.5-3b-instruct-q4_k_m.gguf \
  -p "Explain edge AI deployment in 3 sentences." \
  -n 50 \
  -t 4

# Expected output Raspberry Pi 5:
# - TTFT (Time To First Token): ~800ms-1.2s
# - Throughput: 8-12 tokens/sec (4 threads)
# - Memory usage: ~2GB RAM

echo "llama.cpp deployment complete. Expected tokens/sec: 8-12 on Pi 5" 

# Exportar modelo PyTorch a ExecuTorch para deployment mobile
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from executorch.exir import to_edge

# Cargar modelo PyTorch (Qwen 2.5-3B como ejemplo)
model_name = "Qwen/Qwen2.5-3B-Instruct"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="cpu"
)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Preparar input ejemplo para tracing
sample_input = "Explain edge AI deployment"
inputs = tokenizer(sample_input, return_tensors="pt")

# Export a ExecuTorch format
print("Exporting to ExecuTorch...")
edge_model = to_edge(
    torch.export.export(model, (inputs["input_ids"],))
)

# Guardar modelo exportado
edge_model.to_executorch().save("qwen_3b_executorch.pte")

# Aplicar quantization 4-bit (opcional)
from executorch.backends.xnnpack.partition.xnnpack_partitioner import XnnpackPartitioner

edge_model_quantized = edge_model.to_backend(XnnpackPartitioner())
edge_model_quantized.to_executorch().save("qwen_3b_executorch_quantized.pte")

print("ExecuTorch export complete. Model ready for Android/iOS deployment")
print("Expected size reduction: 70-75% con 4-bit quantization")

# Desplegar modelo ONNX con NPU acceleration (Intel/Qualcomm/NXP)
import onnxruntime as ort
import numpy as np
import time

# Cargar modelo ONNX (convertido desde PyTorch/TensorFlow)
model_path = "qwen_3b_quantized.onnx"

# Session options para NPU acceleration
sess_options = ort.SessionOptions()
sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL

# Providers disponibles (orden de prioridad):
# - "QNNExecutionProvider" (Qualcomm NPU)
# - "OpenVINOExecutionProvider" (Intel NPU/VPU)
# - "CPUExecutionProvider" (fallback)
providers = [
    ("OpenVINOExecutionProvider", {
        "device_type": "NPU",  # NPU, GPU, o CPU
        "precision": "FP16"    # FP32, FP16, o INT8
    }),
    "CPUExecutionProvider"
]

# Crear inference session
session = ort.InferenceSession(
    model_path,
    sess_options=sess_options,
    providers=providers
)

# Verificar provider activo
print(f"Active provider: {session.get_providers()}")

# Preparar input
input_name = session.get_inputs()[0].name
input_data = np.random.randn(1, 3, 224, 224).astype(np.float32)

# Benchmark inference
iterations = 100
start_time = time.time()

for _ in range(iterations):
    outputs = session.run(None, {input_name: input_data})

elapsed_time = time.time() - start_time
avg_latency = (elapsed_time / iterations) * 1000  # ms

print(f"Average latency: {avg_latency:.2f} ms")
print(f"Throughput: {1000/avg_latency:.0f} inferences/sec")
print(f"Expected with Intel NPU: 1.86ms, 538 inferences/sec")

#!/bin/bash
# Setup NVIDIA Jetson Orin Nano para TensorRT-LLM deployment
# Tested: JetPack 6.0, Ubuntu 22.04

echo "Installing TensorRT-LLM dependencies..."
sudo apt-get update
sudo apt-get install -y python3-pip cmake build-essential

# Install TensorRT (viene pre-instalado en JetPack, verificar versión)
dpkg -l | grep TensorRT

# Install PyTorch para Jetson (ARM64)
pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu

# Clone TensorRT-LLM repo (NVIDIA official)
git clone https://github.com/NVIDIA/TensorRT-LLM.git
cd TensorRT-LLM

# Build TensorRT engine para LLaMA-2 7B INT4
# Asume modelo ya quantizado en /models/llama-2-7b-int4
python3 examples/llama/build.py \
  --model_dir /models/llama-2-7b-int4 \
  --output_dir /engines/llama-2-7b-int4-engine \
  --dtype float16 \
  --use_gpt_attention_plugin float16 \
  --use_gemm_plugin float16 \
  --max_batch_size 1 \
  --max_input_len 1024 \
  --max_output_len 512

# Benchmark latency
python3 examples/llama/run.py \
  --engine_dir /engines/llama-2-7b-int4-engine \
  --max_output_len 50 \
  --tokenizer_dir /models/llama-2-7b-int4 \
  --input_text "Explain edge AI deployment in 3 sentences."

echo "TensorRT-LLM setup complete. Expected latency: 70% faster vs llama.cpp"

# Automotive ADAS Edge AI Blueprint
# Use case: Pedestrian detection, lane keeping, adaptive cruise control

hardware:
primary_soc:
    vendor: "Qualcomm"
    model: "Snapdragon Ride Platform"
    tops: 700
    power_budget: "30W"
    redundancy: "Dual NPU (safety-critical)"

sensors:
    - type: "Camera"
    count: 8
    resolution: "8MP"
    fps: 30
    - type: "Radar"
    count: 5
    range: "300m"
    - type: "LiDAR"
    count: 2
    points_per_second: "300k"

model:
framework: "TensorRT (NVIDIA) o Snapdragon Neural Processing SDK"
precision: "INT8"  # Balance accuracy vs latency

models:
    - task: "Object Detection"
    architecture: "YOLO11"
    latency_target: "

# Medical Device Edge AI Blueprint
# Use case: Wearable ECG monitoring, diabetic retinopathy detection

hardware:
wearable_device:
    vendor: "Google Coral NPU"  # Few milliwatts power
    tops: "N/A (specialized for TF Lite)"
    power: "Few milliwatts @ 512 GOPS"
    battery_life: "All-day (wearable requirement)"

diagnostic_device:
    vendor: "NVIDIA Jetson Orin Nano"
    tops: 40
    power: "7-15W"
    use_case: "Medical imaging (retinopathy, X-ray analysis)"

model:
framework: "TensorFlow Lite (Coral) o TensorRT (Jetson)"
precision: "INT8"  # Balance accuracy vs power

tasks:
    - name: "ECG Anomaly Detection"
    accuracy_requirement: ">98%"
    latency: "

# Robotics Edge AI Blueprint
# Use case: Autonomous mobile robots (AMR), delivery drones

hardware:
compute:
    vendor: "NVIDIA Jetson Orin Nano"
    tops: 40
    power: "7-15W"
    framework: "NVIDIA Isaac SDK + ROS 2"

model:
tasks:
    - name: "Object Detection"
    model: "YOLO11"
    precision: "INT8"
    latency: "

# Model Drift Detection Pipeline
# Implementa KS test, Chi-square, PSI para detectar data drift
import numpy as np
from scipy import stats


def calculate_psi(expected, actual, buckets=10):
    """
    Calcula Population Stability Index (PSI) entre distributions.
    
    Args:
        expected: Training data distribution (baseline)
        actual: Production data distribution (current)
        buckets: Number of bins for discretization
    
    Returns:
        psi_value: PSI score (>0.25 = severe drift)
    """
    # Discretize en bins
    breakpoints = np.percentile(expected, np.linspace(0, 100, buckets + 1))
    expected_percents = np.histogram(expected, breakpoints)[0] / len(expected)
    actual_percents = np.histogram(actual, breakpoints)[0] / len(actual)

    # Evitar division por zero
    expected_percents = np.where(expected_percents == 0, 0.0001, expected_percents)
    actual_percents = np.where(actual_percents == 0, 0.0001, actual_percents)

    # Calcular PSI
    psi_value = np.sum((actual_percents - expected_percents) *
                        np.log(actual_percents / expected_percents))

    return psi_value


def detect_drift_ks_test(training_data, production_data, threshold=0.05):
    """
    Kolmogorov-Smirnov test para detectar drift.
    
    Args:
        training_data: Baseline distribution
        production_data: Current distribution
        threshold: P-value threshold (default 0.05)
    
    Returns:
        drift_detected: Boolean
        ks_statistic: KS statistic value
        p_value: P-value
    """
    ks_statistic, p_value = stats.ks_2samp(training_data, production_data)
    drift_detected = p_value < threshold

    return drift_detected, ks_statistic, p_value


# Ejemplo uso:
# Simular training data (baseline)
training_data = np.random.normal(loc=0, scale=1, size=1000)

# Simular production data con drift (mean shifted)
production_data = np.random.normal(loc=0.5, scale=1, size=1000)

# Detectar drift con PSI
psi_score = calculate_psi(training_data, production_data)
print(f"PSI Score: {psi_score:.4f}")

if psi_score > 0.25:
    print("⚠️ SEVERE DRIFT DETECTED - Retrain modelo urgente")
elif psi_score > 0.1:
    print("⚠️ MODERATE DRIFT - Monitor closely")
else:
    print("✅ No significant drift")

# Detectar drift con KS test
drift, ks_stat, p_val = detect_drift_ks_test(training_data, production_data)
print(f"\nKS Test:")
print(f"  KS Statistic: {ks_stat:.4f}")
print(f"  P-value: {p_val:.4f}")
print(f"  Drift Detected: {drift}")

# Matemática de quantization: Memory savings calculation
def calculate_model_memory(parameters, precision):
    """
    Calcula memoria requerida para modelo ML en diferentes precisiones.
    
    Args:
        parameters: Número de parámetros del modelo (ej: 7e9 para LLaMA-2 7B)
        precision: "fp32", "fp16", "int8", "int4"
    
    Returns:
        memory_gb: Memoria en GB
    """
    bytes_per_param = {
        "fp32": 4,    # 32 bits / 8 = 4 bytes
        "fp16": 2,    # 16 bits / 8 = 2 bytes
        "int8": 1,    # 8 bits / 8 = 1 byte
        "int4": 0.5   # 4 bits / 8 = 0.5 bytes
    }

    memory_gb = (parameters * bytes_per_param[precision]) / 1e9
    return memory_gb


# Ejemplos reales:
models = {
    "LLaMA-2 7B": 7e9,
    "Qwen 2.5-3B": 3e9,
    "Qwen 2.5-1.5B": 1.5e9,
    "Phi-3-mini 3.8B": 3.8e9
}

precisions = ["fp32", "fp16", "int8", "int4"]

print("MODEL MEMORY REQUIREMENTS:")
print("=" * 80)

for model_name, params in models.items():
    print(f"\n{model_name} ({params/1e9:.1f}B parameters):")

    for precision in precisions:
        memory = calculate_model_memory(params, precision)
        print(f"  {precision.upper():6s}: {memory:6.2f} GB")

    # Calcular reduction percentages
    fp32_memory = calculate_model_memory(params, "fp32")
    int8_memory = calculate_model_memory(params, "int8")
    int4_memory = calculate_model_memory(params, "int4")

    reduction_int8 = ((fp32_memory - int8_memory) / fp32_memory) * 100
    reduction_int4 = ((fp32_memory - int4_memory) / fp32_memory) * 100

    print(f"  Reduction FP32→INT8: {reduction_int8:.1f}%")
    print(f"  Reduction FP32→INT4: {reduction_int4:.1f}%")

# Output esperado para Qwen 2.5-3B:
# FP32:  12.00 GB ← Imposible en smartphone (4-8GB RAM)
# FP16:   6.00 GB ← Apenas posible en Jetson Orin Nano
# INT8:   3.00 GB ← Viable en smartphones high-end
# INT4:   1.50 GB ← Viable en smartphones mid-range
# Reduction FP32→INT8: 75.0%
# Reduction FP32→INT4: 87.5% 

# Post-Training Quantization con Google AI Edge Quantizer
# Recomendado: Weight-only quantization para LLMs
from ai_edge_torch.quantize import quant_config, quantize
import torch
from transformers import AutoModelForCausalLM

# Cargar modelo PyTorch
model_name = "Qwen/Qwen2.5-3B-Instruct"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float32,  # Cargar en FP32 primero
    device_map="cpu"
)

# Configurar quantization: Weight-only INT8
# (activations mantienen FP32 para mejor accuracy)
quant_config_recipe = quant_config.get_default_config()
quant_config_recipe.set_weight_only_quantization(
    num_bits=8,  # INT8 (usa 4 para INT4)
    granularity="per_channel"  # Per-channel más accurate que per-tensor
)

# Aplicar quantization
print("Aplicando weight-only INT8 quantization...")
quantized_model = quantize(
    model,
    quant_config=quant_config_recipe
)

# Guardar modelo quantizado
output_path = "qwen_3b_int8_weight_only.pt"
torch.save(quantized_model.state_dict(), output_path)

# Verificar memory reduction
original_size_mb = sum(p.numel() * p.element_size() for p in model.parameters()) / (1024**2)
quantized_size_mb = sum(p.numel() * p.element_size() for p in quantized_model.parameters()) / (1024**2)
reduction_pct = ((original_size_mb - quantized_size_mb) / original_size_mb) * 100

print(f"Original model size: {original_size_mb:.2f} MB")
print(f"Quantized model size: {quantized_size_mb:.2f} MB")
print(f"Memory reduction: {reduction_pct:.1f}%")
print(f"Expected accuracy drop: 

# GPTQ 4-bit quantization para LLMs en edge
# Usa AutoGPTQ library (optimizado para CUDA/CPU)
from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig
from transformers import AutoTokenizer

# Configuración GPTQ: 4-bit quantization
quantize_config = BaseQuantizeConfig(
    bits=4,  # INT4
    group_size=128,  # Group size para quantization (128 o 64 típico)
    desc_act=False,  # Activation order (False para mejor speed)
    damp_percent=0.01,
    sym=True,  # Symmetric quantization (mejor hardware support)
    true_sequential=True
)

# Cargar modelo base FP32/FP16
model_name = "Qwen/Qwen2.5-3B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Preparar calibration dataset (pequeño subset training data)
# GPTQ requiere calibration para optimizar quantization scales
calibration_data = [
    "Explain edge AI deployment",
    "What is quantization in ML models",
    # ... 100-500 ejemplos típico
]

# Tokenize calibration data
calibration_tokens = [
    tokenizer(text, return_tensors="pt").input_ids
    for text in calibration_data
]

# Quantizar modelo con GPTQ
print("Quantizando modelo con GPTQ 4-bit...")
quantized_model = AutoGPTQForCausalLM.from_pretrained(
    model_name,
    quantize_config=quantize_config
)

# Aplicar quantization con calibration
quantized_model.quantize(calibration_tokens)

# Guardar modelo quantizado (formato GPTQ optimizado)
output_dir = "./qwen_3b_gptq_int4"
quantized_model.save_quantized(output_dir)
tokenizer.save_pretrained(output_dir)

print(f"GPTQ quantization complete. Model saved to {output_dir}")
print("Expected: 87.5% memory reduction,