Refinamiento de procesos

01 · Punto de partida

De cada diez, me quedo con tres

Llegan 100 pedidos pero solo 30 son prioritarios; de 50 llamadas, 10 son reclamos. Cada evento se clasifica al llegar: se queda con chance p o se deriva a otro flujo.

Ese filtrado es el refinamiento (thinning): lo inverso a superponer. Dividir un Poisson da otros Poisson más lentos e independientes.

• ¿Con qué chance p se queda cada evento?
• ¿Qué tasa tiene el flujo filtrado: p·λ?
• ¿Los flujos resultantes son independientes?
• ¿Y si hay varios tipos (p₁, p₂, p₃)?

02 · Definición

¿Qué es refinar?

Tres piezas del mecanismo:

Refinar y superponer son inversos: dividir con p y q = 1−p y volver a juntar recupera el original.

03 · Anatomía

Moneda, tasa y tipos

Cuatro reglas para refinar sin romper Poisson:

Moneda independiente

La decisión de cada evento no depende de otros ni del tiempo. Si depende (cupos), no es thinning puro.

Tasa × p

El filtrado conserva Poisson con p·λ. p chica = flujo fino y ruidoso.

Tipos multinomiales

Con k tipos, cada evento cae en i con pᵢ. Los k flujos son Poisson independientes.

p(t) variable

Si p depende del tiempo, el filtrado da no homogéneo con p(t)·λ(t). (Base del Tema 18)

04 · Ejemplos

Filtros que un programador programa

Toda clasificación aleatoria por evento es un thinning:

1. 1
   Pedidos prioritarios (p = 0,3).

   De Poisson(10/h) salen Poisson(3/h) prioritarios.

2. 2
   Reclamos (p = 0,2).

   De 50 llamadas, ~10 reclamos Poisson independientes.

3. 3
   Tipos A/B/C.

   p = (0,5 – 0,3 – 0,2): tres Poisson con esas tasas.

4. 4
   Muestreo de logs (p = 0,01).

   Guardar 1 % conserva Poisson fino para estimar.

5. 5
   No thinning: cupo fijo.

   «Los primeros 10» no es moneda por evento: rompe independencia.

05 · Representación en Python

Moneda por evento con random()

En Python, refinar es filtrar la lista con una moneda por evento. El resto sale por complemento: dos listas independientes.

import random, math

random.seed(7)
lam, T, p = 2.0, 10.0, 0.3
t, total = 0.0, []
while True:
    t += -math.log(1 - random.random()) / lam
    if t > T:
        break
    total.append(round(t, 2))

finos = [x for x in total if random.random() < p]
print("total:", len(total), "| finos:", len(finos))

Con λ = 2 y T = 10 se esperan 20 totales y 6 finos (30 %). Otra semilla, otro reparto del mismo p.

Tipos múltiples de una pasada

Con ruleta por evento salen k flujos de una vez:

import random

random.seed(4)
tipos, p = ["A", "B", "C"], [0.5, 0.3, 0.2]
eventos = list(range(10))
salida = {k: 0 for k in tipos}
for _ in eventos:
    u = random.random()
    ac = 0.0
    for k, pk in zip(tipos, p):
        ac += pk
        if u < ac:
            salida[k] += 1
            break
print(salida)

06 · Exploración

Laboratorio: quedarse con chance p

Generamos Poisson(λ) hasta T = 10 y marcamos cada evento: verde = queda (p), gris = se va. Arriba el original con marcas; abajo solo el flujo fino. Movete p: el fino se ralea con tasa p·λ.

Cada tick gris es un evento descartado; cada verde, uno que queda. El fino conserva el azar Poisson con menos tasa.

Preguntas para explorar

1. Con p = 0,3, ¿qué % queda? ¿Cerca de 30 % siempre o en promedio?
2. Bajá p a 0,1. ¿El fino sigue Poisson? ¿Con qué tasa y qué ruido?
3. ¿Finos + resto recuperan el total? ¿Son independientes?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: tasa del fino

Con λ = 8/hora y p = 0,25, ¿qué tasa tiene el fino y cuántos se esperan en 4 h?

lam, p, T = 8.0, 0.25, 4
print("tasa fino:", lam * p)
print("esperados:", lam * p * T)

Ejercicio 2: verificar el reparto

Sin ejecutar primero: con 40 totales y p = 0,3, ¿cuántos finos esperás? Comprobalo con monedas.

import random

random.seed(2)
finos = sum(1 for _ in range(40) if random.random() < 0.3)
print(finos, "| esperado:", 12)

Ejercicio 3: fino + resto = total

Refiná una lista y verificá que fino y resto son disjuntos y suman el total.

import random

random.seed(6)
total = [0.5, 1.2, 2.1, 3.7, 4.4]
finos = [x for x in total if random.random() < 0.4]
resto = [x for x in total if x not in finos]
print(len(finos), len(resto), len(finos) + len(resto) == len(total))

09 · Síntesis

Ideas para recordar

En el próximo tema usaremos el refinamiento para simular con tasa variable.