Simulación por refinamiento

01 · Punto de partida

Simular lo variable con lo parejo

Generar un Poisson no homogéneo directo es difícil: el ritmo cambia a cada hora. La idea del refinamiento (Lewis-Shedler) es generar de más con ritmo parejo alto y podar donde λ(t) es baja.

Se proponen candidatos con la tasa máxima λ* y cada uno se acepta con chance λ(t)/λ*: en el pico casi todos quedan, en el valle casi todos caen.

• ¿Qué techo λ* cubre a toda la curva?
• ¿Con qué chance se acepta un candidato en t?
• ¿Qué fracción sobrevive en promedio: la eficiencia?
• ¿El resultado es Poisson con λ(t)?

02 · Definición

El algoritmo en tres pasos

Todo thinning-simulador hace lo mismo:

La eficiencia es Λ/(λ*·T): fracción aceptada en promedio. Pico fino sobre base baja = muchos candidatos desperdiciados.

03 · Anatomía

Techo, moneda y eficiencia

Cuatro decisiones del algoritmo:

Techo λ*

Debe cubrir toda la curva (λ* ≥ λ(t) ∀t). Más alto = más candidatos inútiles; más bajo = inválido.

Moneda λ(t)/λ*

Independiente por candidato. En el pico ≈ 1, en el valle ≈ base/λ*.

Eficiencia Λ/(λ*T)

Fracción aceptada media. Si es 5 %, conviene partir el día por tramos con techos locales.

Exactitud

El método es exacto (no aproximado): lo aceptado es NHPP con λ(t) sin discretizar.

04 · Ejemplos

Thinning en la práctica

Siempre que el ritmo varía y se conoce el techo:

1. 1
   Hospital (λ* = 4).

   Candidatos parejos; de noche cae el 75 %, al mediodía queda casi todo.

2. 2
   Servidor con pico.

   Base 10 + pico 50: λ* = 60. Eficiencia baja pero exacta.

3. 3
   Dos turnos.

   λ* noche = 1, λ* día = 5. Dos techos, doble eficiencia.

4. 4
   Pico fino.

   Aguja breve: muchos candidatos, pocos aceptados. Partir el día ayuda.

5. 5
   λ* = λ (plano).

   Sin pico no hay rechazo: vuelve al homogéneo puro.

05 · Representación en Python

Candidatos + moneda con lam(t)

En Python, el algoritmo son dos sorteos por candidato: la espera Exp(λ*) y la moneda uniforme contra λ(t)/λ*. Se devuelve (aceptados, rechazados) para auditar.

import random, math

def lam(t, base=1.0, pico=3.0):
    return base + pico * math.exp(-((t - 12) ** 2) / 18)

def simular_thinning(T=24.0, base=1.0, pico=3.0, semilla=7):
    lam_star = base + pico
    random.seed(semilla)
    t, acept, rech = 0.0, [], []
    while True:
        t += -math.log(1 - random.random()) / lam_star
        if t > T:
            break
        if random.random() < lam(t, base, pico) / lam_star:
            acept.append(round(t, 2))
        else:
            rech.append(round(t, 2))
    return acept, rech

a, r = simular_thinning()
print("aceptados:", len(a), "| rechazados:", len(r))

Con base 1 y pico 3 (λ* = 4) salen ~96 candidatos y ~39 aceptados. La eficiencia ronda 41 %.

Medir la eficiencia

Eficiencia = aceptados / candidatos, teoría Λ/(λ*T):

a, r = simular_thinning(semilla=8)
print("eficiencia:", round(len(a) / (len(a) + len(r)), 3))

06 · Exploración

Laboratorio: proponer mucho, quedarse con lo justo

Curva λ(t) con base + pico al mediodía y techo λ* punteado. Cada tick es un candidato: verde = aceptado, gris = rechazado. Subí el pico: λ* sube, hay más candidatos y el mediodía se llena de verdes.

De noche casi todos los candidatos caen (grises); al mediodía casi todos quedan (verdes). La eficiencia mide el desperdicio.

Preguntas para explorar

1. Con pico = 0, ¿cuántos se rechazan? ¿Qué eficiencia da y por qué?
2. Subí el pico a 6 con igual base. ¿Sube o baja la eficiencia? ¿Por qué?
3. ¿Dónde caen los verdes y dónde los grises? ¿Qué dice eso de λ(t)/λ*?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: eficiencia teórica

Con base 1, pico 3 y T = 24 (Λ ≈ 39,2), calculá λ*, candidatos esperados y eficiencia.

lam_star, T, Lambda = 4.0, 24, 39.2
print("candidatos:", lam_star * T)
print("eficiencia:", round(Lambda / (lam_star * T), 3))

Ejercicio 2: chance por hora

Sin ejecutar primero: con base 1, pico 3 (λ* = 4), ¿qué chance de aceptar hay a las 0 h y a las 12 h?

print("0 h:", 1.0 / 4)
print("12 h:", 4.0 / 4)

Ejercicio 3: techos por tramo

Partí el día en noche (λ* = 1, T = 12) y día (λ* = 4, T = 12). ¿Cuántos candidatos totales vs techo global 4×24?

print("global:", 4 * 24)
print("tramos:", 1 * 12 + 4 * 12)

09 · Síntesis

Ideas para recordar

Cerramos Poisson. En el próximo tema empieza Markov: concepto de cadena de Markov.