Análisis de sensibilidad

01 · Punto de partida

No todos los parámetros pesan igual

En el logístico, mover r un 20 % cambia el tiempo de llegada; mover K un 20 % cambia el techo. ¿Cuál mueve más el final en T = 10? La respuesta no es opinión: se mide perturbando uno a la vez y comparando el cambio en la salida.

La sensibilidad ordena el trabajo: lo sensible se calibra fino, lo insensible se deja nominal.

• ¿Qué salida miro (final, pico, tiempo)?
• ¿Cuánto cambia con +10 % en cada parámetro?
• ¿Cuál ranking sale (r vs K)?
• ¿El ranking cambia con el horizonte?

02 · Definición

¿Qué es el análisis de sensibilidad?

Perturbar uno a la vez y medir:

Sin relativizar, K (decenas) siempre «mueve más» que r (décimas): la elasticidad pone la cancha pareja.

03 · Anatomía

Salida, perturbación y horizonte

La sensibilidad tiene tres patas:

Salida Y

Qué miro: P(T), pico, t90. Cada salida tiene su ranking distinto.

Perturbación ±10 %

Relativa y simétrica: compara r con K sin sesgo de unidades.

Horizonte T

En T corto manda r (velocidad); en T largo manda K (destino).

Interacción

Uno a la vez ignora sinergias: r y K juntos pueden sorprender (Tema 41).

04 · Sensibilidad en el curso

Quién manda en cada modelo

Cada modelo tiene su perilla brava:

1. 1
   Tanque.

   q manda el nivel (1 a 1); k manda tiempo y nivel. Empate técnico.

2. 2
   Exponencial.

   r manda exponencial: +10 % en r se potencia en T largo.

3. 3
   SIR.

   R₀ = β/γ manda el pico: β y γ empatan en R₀.

4. 4
   Térmico.

   P/k manda el destino; k manda el reloj.

5. 5
   Resorte.

   k manda frecuencia; c manda apagado. Salidas distintas, reyes distintos.

05 · Representación en Python

Elasticidad en una función

En Python, la sensibilidad es perturbar y comparar: base contra +10 %, en relativo.

import math


def p_final(r=0.5, k=100.0, p0=10.0, t=10.0):
    return k / (1 + (k - p0) / p0 * math.exp(-r * t))


def elasticidad(parametro="r", delta=0.1, t=10.0):
    base = p_final(t=t)
    if parametro == "r":
        nuevo = p_final(r=0.5 * (1 + delta), t=t)
    else:
        nuevo = p_final(k=100.0 * (1 + delta), t=t)
    return ((nuevo - base) / base) / delta


print("E_r:", round(elasticidad("r"), 3))
print("E_K:", round(elasticidad("k"), 3))

E_r ≈ 0,18 · E_K ≈ 0,97: en T = 10, K mueve 5 veces más que r.

Ranking automático

Ordenar por |E| decide dónde calibrar:

ranking = sorted([("r", elasticidad("r")), ("K", elasticidad("k"))], key=lambda q: abs(q[1]), reverse=True)
print([(n, round(e, 3)) for n, e in ranking])

06 · Exploración

Laboratorio: quién mueve P(T)

Base dorada (r = 0,5, K = 100, P₀ = 10). Teal: tu r con K base. Naranja: tu K con r base. Barras laterales: cambio absoluto por r y por K. Movete el horizonte y observá el cambio de mando: en T corto gana r, en largo gana K.

Las barras comparan cambios absolutos en P(T); los paréntesis dan elasticidades. El ganador se lleva la calibración fina.

Preguntas para explorar

1. Con T = 3, ¿quién gana: r o K? ¿Por qué se da vuelta?
2. Con tu r = 0,8 y K = 100, ¿la brecha se achica? ¿El ranking cambia?
3. Si la salida fuera t90 en vez de P(10), ¿quién mandarías a calibrar?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: elasticidad a mano

Base P(10) ≈ 94,3; con K +10 % da 103,4. Calculá E_K. ¿Mueve casi 1 a 1?

print(round(((103.4 - 94.3) / 94.3) / 0.1, 3))

Ejercicio 2: ranking en T corto

Calculá E_r y E_K en T = 4 con +10 %. ¿Se da vuelta el ranking?

import math


def p_final(r=0.5, k=100.0, t=4.0):
    return k / (1 + 9 * math.exp(-r * t))


base = p_final()
e_r = ((p_final(r=0.55) - base) / base) / 0.1
e_k = ((p_final(k=110.0) - base) / base) / 0.1
print(round(e_r, 3), round(e_k, 3))

Ejercicio 3: ¿qué calibrar?

Si r tiene ±5 % de incerteza y K ±20 %, ¿cuál aporta más varianza en P(10)? Ponderá E × incerteza.

print("r:", round(0.18 * 0.05, 4), "K:", round(0.97 * 0.20, 4))

09 · Síntesis

Ideas para recordar

En el próximo tema perturbaremos todo junto: experimentación con parámetros.