Tasa de ocurrencia

01 · Punto de partida

Un número gobierna la velocidad

Dos call centers con igual azar pueden ir a ritmos opuestos: uno recibe 2 llamadas por hora y otro 30. La diferencia es un solo número: la tasa λ.

λ dice cuántos eventos caen en promedio por unidad de tiempo. Manda la pendiente de N(t), la espera media 1/λ y la escala de toda la simulación.

• ¿Cuántos eventos por hora, minuto o segundo: con qué unidad?
• ¿Qué cambia si λ se duplica: el doble de todo?
• ¿Cómo se estima λ desde datos: N(T)/T?
• ¿Cuánto hay que observar para estimar bien?

02 · Definición

¿Qué es la tasa λ?

Tres lecturas del mismo número:

λ no es probabilidad: puede valer 0,5 o 40. La probabilidad vive en ventanas chicas (λ·dt) o en la fórmula Po(λt).

03 · Anatomía

Unidades, escala y estimación

Cuatro reglas para no equivocarse con λ:

Unidades

λ siempre lleva «por tiempo»: λ = 3/hora. Sin unidad, el número no significa nada.

Escala lineal

Duplicar λ duplica la media en igual T: E[N] = λT. El proceso se acelera parejo.

Estimación

λ̂ = N(T)/T. Con T chico fluctúa; con T grande se pega a λ (ley de grandes números).

Horizonte necesario

Para estimar bien hacen falta decenas de eventos, no decenas de minutos. Poco conteo = mucho ruido.

04 · Ejemplos

Tasas que un programador configura

λ es el primer parámetro que se calibra en cualquier simulador de arribos:

1. 1
   Call center: 120/día.

   En 8 h: λ̂ = 15/hora, espera media 4 min.

2. 2
   Servidor: 3600/hora.

   λ = 1/segundo. Escala natural para tests de carga.

3. 3
   Fallas: 1 por semana.

   λ = 1/7 día. Pocos eventos: hace falta observar meses.

4. 4
   Duplicar personal.

   Si λ se duplica y el servicio no, la cola se dispara (Tema 2).

5. 5
   Cambio de unidad.

   λ = 2/min = 120/hora = 0,033/seg. Mismo ritmo, tres escrituras.

05 · Representación en Python

λ entra, N(T)/T sale

En Python, λ es un argumento del generador y N(T)/T es la medición. Generar con una λ y recuperar algo cercano verifica el simulador.

import random, math

def estimar_lambda(T, lam=2.0, semilla=7):
    random.seed(semilla)
    t, n = 0.0, 0
    while True:
        t += -math.log(1 - random.random()) / lam
        if t > T:
            break
        n += 1
    return n / T

for T in [5, 50]:
    print(T, round(estimar_lambda(T), 3))

Con T = 5 el cociente fluctúa; con T = 50 se pega a 2,0. El horizonte manda la precisión.

Convertir unidades sin errores

Una función chica evita el error clásico de unidades:

def convertir(lam, de_minutos=60):
    # lam por hora -> por minuto, por segundo...
    return lam / de_minutos

lam_hora = 120
print("por hora:", lam_hora)
print("por minuto:", convertir(lam_hora, 60))
print("espera media (min):", round(1 / convertir(lam_hora, 60), 2))

06 · Exploración

Laboratorio: N(t)/t converge a λ

Cada curva es la tasa empírica N(t)/t de una réplica hasta T = 20. Al inicio oscila salvaje (dividir por t chico); con el tiempo se pega a la recta blanca λ. Cambiá λ y mirá cómo todas la persiguen.

El eje horizontal es el tiempo observado; el vertical, la tasa medida. Observar poco es ruidoso; observar mucho estima bien.

Preguntas para explorar

1. Con λ = 2, mirá t = 2 vs t = 20. ¿Dónde se dispersan más las curvas? ¿Por qué?
2. Subí λ a 4. ¿La convergencia es más rápida en tiempo o en eventos? (Pista: mirá N.)
3. ¿Qué pasa si estimás λ con una sola réplica y T = 2?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: estimar desde un log

Este log cubre 4 horas con 26 pedidos. Estimá λ por hora y la espera media en minutos.

N, T_horas = 26, 4
lam = N / T_horas
print("lambda/hora:", lam)
print("espera media (min):", round(60 / lam, 1))

Ejercicio 2: escalar λ

Sin ejecutar primero: si λ = 1,5/hora, ¿cuántos se esperan en 10 horas? ¿Y la espera media?

lam = 1.5
print("E[N(10)]:", lam * 10)
print("espera media (h):", round(1 / lam, 3))

Ejercicio 3: precisión vs horizonte

Compará el error típico de λ̂ con T = 5 y T = 100 (λ = 2). ¿En qué factor cae?

import random, math, statistics

def estimar(T, lam=2.0):
    t, n = 0.0, 0
    while True:
        t += -math.log(1 - random.random()) / lam
        if t > T:
            return n / T
        n += 1

for T in [5, 100]:
    random.seed(13)
    vals = [estimar(T) for _ in range(300)]
    print(T, round(statistics.pstdev(vals), 3))

09 · Síntesis

Ideas para recordar

En el próximo tema la tasa dejará de ser constante: función de intensidad λ(t).