Analizar, optimizar y verificar

01 · El desafío

Ajustar el esfuerzo de un proceso

Un programa ejecuta una cantidad configurable x de muestras internas. Aumentar x mejora la calidad del resultado, pero consume más tiempo y memoria. Valores muy bajos producen errores; valores muy altos desperdician recursos.

El objetivo es elegir una configuración que minimice un costo compuesto. El programa admite cantidades enteras entre 5 y 100, aunque primero resolveremos el modelo continuo para comprender su estructura.

02 · Contrato del problema

Decisión, objetivo y restricciones

Estas decisiones deben acordarse antes de optimizar. Cambiar el dominio, la escala o el significado del costo después de ver el resultado equivale a resolver otro problema.

03 · Función objetivo

Combinar calidad y recursos

Las mediciones normalizadas sugieren el modelo:

Ambos términos son adimensionales después de normalizar las métricas originales. Q mejora cada vez menos al aumentar el esfuerzo, mientras R crece de forma constante.

El modelo es válido solo para x>0; la restricción operativa lo reduce a [5,100].

04 · Solución analítica

Derivar y generar el candidato

La condición estacionaria es:

La raíz negativa no pertenece al dominio. El candidato positivo está dentro de [5,100].

05 · Justificar el mínimo

Convexidad y fronteras

Para x>0:

La función es estrictamente convexa. El único punto estacionario es, por lo tanto, el mínimo global en el dominio positivo. Aun así, verificamos el intervalo cerrado:

06 · Configuración implementable

Comparar los enteros vecinos

El programa no acepta 40,8248 muestras. Comparamos los enteros próximos y, como protección, un vecino adicional:

La configuración final del modelo es x=41. La pequeña diferencia con 40 también advierte que el ruido de medición podría volverlas prácticamente equivalentes.

07 · Verificación por muestreo

Búsqueda exhaustiva en una grilla

Dividimos [5,100] en 20 subintervalos. El paso es:

La grilla realiza 21 evaluaciones y elige x=43, con J(x)≈7,3584. No coincide con el óptimo porque 40,8248 no pertenece a esa grilla.

Al aumentar la resolución, el mejor punto se acerca a la solución analítica. Si evaluamos directamente todos los enteros de 5 a 100, la búsqueda exhaustiva confirma x=41 con 96 evaluaciones.

08 · Verificación sin derivadas

Búsqueda ternaria

Como J″(x)>0, la función es convexa y, por tanto, unimodal para minimización. La búsqueda ternaria puede descartar tercios con seguridad.

Partiendo de [5,100] y deteniéndose cuando el ancho es menor que 10−6, obtiene una aproximación cercana a:

El acuerdo con el resultado analítico verifica tanto la derivación como la implementación numérica, aunque ambos métodos todavía comparten el mismo modelo.

09 · Verificación iterativa

Descenso guiado por J′

Desde x₀=80, usamos:

Con α=50, el método avanza hacia el mínimo sin abandonar el dominio. Cerca de x*, la curvatura es aproximadamente J″(x*)≈0,00441; el factor lineal local es cercano a 1−50·0,00441≈0,7795.

El descenso aporta una tercera perspectiva, pero su resultado depende del paso, el punto inicial, el criterio de parada y la proyección al intervalo.

10 · Resultados cruzados

Qué aporta cada método

La coincidencia no demuestra que el modelo describa la realidad; demuestra que varios procedimientos resuelven de forma consistente el mismo modelo.

11 · Criterios de aceptación

Cómo decidir que la solución es correcta

Antes de ejecutar, definimos comprobaciones concretas:

• el resultado continuo debe pertenecer a [5,100];
• |J′(x)| debe ser pequeño en la solución interior;
• J″(x)>0 debe confirmar el mínimo;
• las fronteras no deben mejorar el valor;
• ternaria y descenso deben quedar dentro de una tolerancia del valor analítico;
• la búsqueda entera debe confirmar que 41 no es peor que 40 ni 42;
• ningún algoritmo debe producir NaN o salir del dominio.

Una prueba debe indicar qué propiedad protege. Comparar solo contra un número copiado puede ocultar errores compartidos.

12 · Robustez de la decisión

Variar los parámetros del modelo

Para J(x)=a/x+kx, el óptimo continuo es:

Si la penalización de calidad a aumenta 10 %, el óptimo se multiplica por √1,1≈1,0488. Si el costo de recursos k aumenta 10 %, se multiplica por 1/√1,1≈0,9535.

La raíz cuadrada amortigua los cambios: una variación relativa pequeña en los parámetros produce aproximadamente la mitad de esa variación en x*, con signo positivo para a y negativo para k.

13 · Del modelo al programa

Validar con mediciones independientes

La última verificación debe ocurrir en el sistema real. Ejecutamos configuraciones alrededor de la propuesta —por ejemplo 38, 40, 41, 42 y 44— con cargas representativas y repeticiones.

Debemos registrar:

• versiones del programa, dependencias y hardware;
• semillas, datos de entrada y período de calentamiento;
• métricas originales antes de normalizarlas;
• promedios o medianas junto con su dispersión;
• fallos, límites de memoria y tiempos agotados;
• diferencias entre los datos de ajuste y los de validación.

Si 40 y 41 son indistinguibles dentro de la incertidumbre, una política razonable puede elegir 40 por consumir menos recursos, aunque el modelo determinista favorezca 41.

14 · Exploración interactiva

Laboratorio: cuatro métodos, una función

Modificá la resolución de la grilla y los parámetros del descenso. La solución analítica y la ternaria sirven como referencias continuas.

La curva representa el costo compuesto y los marcadores identifican las soluciones analítica, exhaustiva, ternaria e iterativa.

Preguntas para explorar

1. ¿La mejor muestra de la grilla se acerca de forma monótona al aumentar n?
2. Reducí las iteraciones de descenso. ¿Qué información adicional necesitás para evaluar el resultado?
3. Aumentá α. ¿En qué momento la trayectoria toca una frontera o deja de estabilizarse?
4. Buscá una grilla que contenga un punto muy próximo a 40,8248.

15 · Implementación integrada

Resolver el modelo con cuatro estrategias

const modelo = {
  min: 5,
  max: 100,
  costo: x => 150 / x + 0.09 * x,
  derivada: x => -150 / x ** 2 + 0.09
};

function solucionAnalitica() {
  const x = Math.sqrt(150 / 0.09);
  return { metodo: "analítico", x, valor: modelo.costo(x) };
}

function buscarGrilla(subintervalos) {
  let mejor = { x: modelo.min, valor: modelo.costo(modelo.min) };
  for (let i = 1; i <= subintervalos; i++) {
    const x = modelo.min + (modelo.max - modelo.min) * i / subintervalos;
    const valor = modelo.costo(x);
    if (valor < mejor.valor) mejor = { x, valor };
  }
  return { metodo: "grilla", ...mejor, evaluaciones: subintervalos + 1 };
}

function buscarTernaria(tolerancia = 1e-7) {
  let izquierda = modelo.min;
  let derecha = modelo.max;
  let evaluaciones = 0;
  while (derecha - izquierda > tolerancia) {
    const m1 = izquierda + (derecha - izquierda) / 3;
    const m2 = derecha - (derecha - izquierda) / 3;
    const y1 = modelo.costo(m1);
    const y2 = modelo.costo(m2);
    evaluaciones += 2;
    if (y1 < y2) derecha = m2;
    else izquierda = m1;
  }
  const x = (izquierda + derecha) / 2;
  return { metodo: "ternaria", x, valor: modelo.costo(x), evaluaciones };
}

function descenso(inicio = 80, paso = 50, iteraciones = 100) {
  let x = inicio;
  for (let k = 0; k < iteraciones; k++) {
    x -= paso * modelo.derivada(x);
    x = Math.min(modelo.max, Math.max(modelo.min, x));
  }
  return { metodo: "descenso", x, valor: modelo.costo(x), iteraciones };
}

console.log([
  solucionAnalitica(),
  buscarGrilla(20),
  buscarTernaria(),
  descenso()
]);

Resolver la decisión entera y verificar vecinos

function costo(x) {
  if (!(x > 0)) return Infinity;
  return 150 / x + 0.09 * x;
}

function mejorEntero(min, max) {
  if (!Number.isInteger(min) || !Number.isInteger(max) || min > max) {
    throw new RangeError("Intervalo entero inválido");
  }
  let mejor = { x: min, valor: costo(min) };
  for (let x = min + 1; x <= max; x++) {
    const valor = costo(x);
    if (valor < mejor.valor) mejor = { x, valor };
  }
  return mejor;
}

const mejor = mejorEntero(5, 100);
const vecinos = [mejor.x - 1, mejor.x, mejor.x + 1]
  .map(x => ({ x, valor: costo(x) }));

console.log("Mejor configuración:", mejor);
console.log("Vecinos:", vecinos);
console.assert(mejor.x === 41, "Se esperaba x = 41");
console.assert(costo(41) <= costo(40) && costo(41) <= costo(42));

16 · Pruebas y casos límite

Qué debería cubrir una suite real

• Modelo: rechazar x≤0 y resultados no finitos.
• Fronteras: probar dominios que excluyan al candidato continuo.
• Grilla: incluir ambos extremos y validar n≥1.
• Ternaria: limitar iteraciones y rechazar tolerancias no positivas.
• Descenso: detectar estancamiento en una frontera y valores divergentes.
• Discreto: probar intervalos de un único entero y empates.
• Consistencia: comparar métodos dentro de tolerancias explícitas.

También conviene introducir deliberadamente una derivada incorrecta. La grilla y la ternaria deberían discrepar del método analítico y del descenso, demostrando que la verificación cruzada realmente detecta fallos.

17 · Comprensión

Errores que invalidan el proyecto

18 · Trabajo propuesto

Extender y defender la solución

Extensión 1: límite de recursos

Agregá la restricción x≤35. Determiná la solución continua, la entera y qué métodos llegan a ella.

Extensión 2: cambiar prioridades

Reemplazá 0,09 por 0,12. Calculá el nuevo óptimo y explicá el desplazamiento.

Extensión 3: presupuesto de evaluaciones

Compará el error de una grilla con 31 evaluaciones y una búsqueda ternaria con 30 evaluaciones.

Extensión 4: informe técnico

Prepará una recomendación que incluya modelo, supuestos, resultado, sensibilidad, evidencia experimental y condiciones para volver a optimizar.

Extensión 5: función no unimodal

Agregá un término oscilatorio pequeño, por ejemplo 0,2sin(x), y compará nuevamente los métodos.

19 · Cierre del curso

Un proceso completo de optimización

Optimizar no consiste únicamente en hallar dónde una derivada se anula. Consiste en construir una pregunta precisa, resolverla con herramientas adecuadas y reunir evidencia suficiente para confiar en la respuesta.