Las organizaciones que gestionan operaciones cada vez más robustas, requieren en cierto modo de la asignación de personas y recursos a tareas específicas. Desde hace algún tiempo se ha popularizado un planteamiento en torno al objetivo de la logística, generalmente aceptado como: «El objetivo de la logística consiste en llevar el producto correcto, en la cantidad correcta, en el lugar correcto, en el momento correcto» (acepta variaciones).

Ahora bien, tendencias de optimización abordan nuevos objetivos y plantean nuevos desafíos alrededor de la intralogística: optimización extrema. Es decir, optimización en la asignación de recursos internos, como por ejemplo: el recurso correcto, asignado a la tarea correcta, en el momento correcto.

Cuando aterrizamos el anterior planteamiento en términos prácticos, entendemos que se hace necesario resolver problemas de programación complejos de forma regular, que permitan la gestión de las operaciones de la organización. Un caso puntual consiste en la programación del recurso humano, sujeta a un conjunto complejo de restricciones y requisitos: número de empleados, días laborales, turnos, tiempos inactivos, permisos, políticas internas, etc.

El planteamiento de nuevos desafíos de optimización, guarda una estrecha relación con la posibilidad que nos brinda la tecnología de abordar estos retos. Si bien, la complejidad de las organizaciones es cada vez mayor, los algoritmos cada vez son más refinados, y los solucionadores cada vez más robustos e integrados.

El objetivo de este artículo consiste en utilizar las técnicas robustas del solucionador basado en restricciones OR-Tools de Google, para resolver un problema de programación de empleados sujeto a un conjunto complejo de restricciones.

Caso de aplicación

La compañía Stark Lab ha adquirido un nuevo torno para su área de mecanizado. El volumen de trabajo que tiene el área, demanda que esta nueva máquina sea operada en los 3 turnos del día (mañana, tarde y noche).

La compañía ha contratado a 3 trabajadores para operar la nueva máquina, y planea emplear a un aprendiz (estudiante) como cuarto operario.

El supervisor debe diseñar una programación para los cuatro operarios para un periodo de 7 días (una semana), sujeto a las siguientes condiciones:

• Cada día se divide en tres turnos de 8 horas.
• Todos los días, cada turno se asigna a un solo operario, y ningún operario trabajará más de un turno por día.
• El último día de la programación se realizan actividades de mantenimiento y limpieza profunda en planta. Por tal razón, solo se trabaja el turno de la mañana.
• El operario aprendiz (estudiante), cuenta con la colaboración de la compañía para realizar sus estudios. Por tal razón, no puede trabajar el tercer día de la semana en el turno de la noche.
• Como mínimo deben trabajarse 19 turnos en total en la programación. Esta cantidad de turnos ya considera los turnos destinados a mantenimiento y limpieza del último día de la programación.
• En el caso en el que no se pueda realizar una distribución de turnos igualitaria, la distribución de los turnos debe realizarse de manera uniforme. Esto quiere decir que no puede existir una diferencia mayor a un turno entre las asignaciones para cada operario.

Se desea desarrollar una programación de empleados (asignación de empleados, turnos y días), que cumpla con las restricciones del planteamiento.

¿Qué necesitaremos?

En el desarrollo de este ejercicio emplearemos:

Paso 1: Crear el entorno de trabajo en Colaboratory

Lo primero que vamos a hacer consiste en crear un entorno de trabajo en Google Colaboratory, así que vayamos allá: Abrir cuaderno nuevo.

Verán que tienen un lienzo para programar el modelo, así que en este cuaderno podemos ir generando las líneas de código que explicaremos en los pasos siguientes.

Paso 2: Instalar Google Or Tools

Es necesario instalar la librería de Google Or Tools en nuestro entorno de Colaboratory para poder utilizar nuestro modelo de programación entera.

!pip install ortools

Al ejecutar esta instrucción instalaremos el software del solucionador de Google.

Paso 3: Importar las librerías necesarias

Este modelo empleará programación entera, y por lo tanto instalaremos las librerías dispuestas por Google OR Tools para ello. En este caso utilizaremos un solucionador de programación entera llamado CP-SAT.

#Importar la librería para utilizar CP-SAT
from ortools.sat.python import cp_model

De esta manera, tenemos todo lo necesario para empezar a desarrollar nuestro código.

Paso 4: Crear los datos de entrada del modelo

Los datos de entrada de un problema de programación de empleados suelen ser simples, la complejidad recae en el modelamiento de las restricciones. En este caso, los datos de entrada básicos son: número de empleados, número de turnos por día, número de días del plan de programación.

#Datos de entrada del modelo
operarios = 4
turnos = 3
dias = 7
total_operarios = range(operarios)
total_turnos = range(turnos)
total_dias = range(dias)

turnos_no_laborales = 2
turnos_laborales = (turnos * dias) - turnos_no_laborales

Así mismo, definimos el número de turnos no laborales, recordemos que el planteamiento del problema nos indicó que el último día se trabajaría tan solo un turno (por labores de mantenimiento y limpieza), por lo tanto, dos turnos pueden considerarse como no laborales.

¿Por qué utilizamos una variable llamada operarios y otra llamada total_operarios? Además, ¿Para qué se emplea la función range? Bueno, la variable operarios contendrá el valor entero de la cantidad de operarios del modelo; mientras tanto, la variable total_operarios dado que emplea la función range, contendrá la secuencia de números que nos ayudará a definir a cada operario, lo hace de esta manera: range(4) = 0, 1, 2, 3. Como podemos ver, inicia la secuencia en 0, y finaliza en el entero anterior al parámetro dado, en este caso el parámetro dado fue 4, por lo tanto, el entero anterior será 3.

Paso 5: Crear el modelo de programación

#Crear el modelo
model = cp_model.CpModel()

Paso 6: Crear las variables de asignación

El problema de programación de empleados es un caso de asignación, y por lo tanto, empleamos variables de decisión de asignación. Veamos:

Necesitamos definir qué operario será asignado a qué turno en qué día en específico. Por lo tanto podemos utilizar variables de asignación binarias, que tomen un valor de 1, si esa asignación específica tiene lugar, y tomen valor de 0, en el caso en el que no.

Algebraicamente sería algo así:

En el caso en el que tuviésemos que definir manualmente cada una de las variables de asignación, requeriríamos un total de 84 variables (7 días * 3 turnos * 4 operarios).

Veamos cómo podemos utilizar los ciclos en Python para simplificar la definición de las variables – Eso sí, en lugar de X llamaremos a la variable asignacion, y en lugar de a, b y c, utilizaremos la primera letra de cada parámetro.

# Creamos las variables de asignación
# asignacion[(o, d, t)]: operario 'o' trabaja en el turno 't' el día 'd'.
asignacion = {}
for o in total_operarios:
    for d in total_dias:
        for t in total_turnos:
            asignacion[(o, d, t)] = model.NewBoolVar('turno_n%id%is%i' % (o, d, t))

De esta manera, haciendo uso de ciclos, creamos todas las variables de asignación del modelo; así mismo, definimos su naturaleza (NewBoolVar = Variable booleana). De manera que en el caso de que una asignación se efectúe su resultado será «verdadero / True».

Paso 7: Crear las restricciones del modelo

La complejidad de un problema de programación de recursos se define por la naturaleza de sus restricciones. Si bien las restricciones acotan el conjunto solución, y por ende los tiempos de procesamiento, la dificultad subyace del modelamiento. Veamos cómo abordar cada una de las restricciones que nos plantea el caso de aplicación.

Cada turno se asigna a un solo operario

La sumatoria de todas las asignaciones efectuadas en un día d, en el turno t, deben ser menores o iguales a 1. Eso restringe la posibilidad de que un mismo turno, en un mismo día, sea asignado a dos operarios diferentes.

Por ejemplo:

X₀₀₀ + X₁₀₀ + X₂₀₀ + X₃₀₀ <= 1

Esta restricción nos diría que la sumatoria de todas las asignaciones del día 0, para el turno 0, de los operarios 0, 1, 2 y 3; debe ser menor o igual a 1. Es decir que el turno 0, del día 0 no puede ser asignado a más de un operario.

Veamos cómo Python nos puede simplificar esta formulación de restricciones:

# Cada turno es asignado a un operario en el periodo de programación, o no es asignado
for d in total_dias:
    for t in total_turnos:
        model.Add(sum(asignacion[(o, d, t)] for o in total_operarios) <= 1)

Esta restricción bien podría formularse como que la sumatoria deba ser igual a 1. Sin embargo, recordemos que existen un par de turnos no laborales, y por lo tanto estos no deben ser asignados.

En el caso en el que tuviésemos que definir manualmente cada una de estas restricciones, requeriríamos un total de 21 restricciones (7 días * 3 turnos).

Cada operario trabaja como máximo un turno por día

La sumatoria de todas las asignaciones efectuadas en un día d, para el operario o, deben ser menores o iguales a 1. Eso restringe la posibilidad de que un operario, en un mismo día, sea asignado a dos turnos diferentes.

Por ejemplo:

X₀₀₀ + X₀₀₁ + X₀₀₂ <= 1

Esta restricción nos diría que la sumatoria de todas las asignaciones del día 0, para el operario 0, de los turnos 0, 1, y 2; debe ser menor o igual a 1. Es decir que el operario 0, del día 0 no puede ser asignado a más de un turno.

Veamos cómo Python nos puede simplificar esta formulación de restricciones:

# Cada operario trabaja como máximo un turno por día
for o in total_operarios:
    for d in total_dias:
        model.Add(sum(asignacion[(o, d, t)] for t in total_turnos) <= 1)

En el caso en el que tuviésemos que definir manualmente cada una de estas restricciones, requeriríamos un total de 28 restricciones (7 días * 4 operarios).

Restricción del operario aprendiz

De acuerdo al caso de aplicación, el operario aprendiz no pude trabajar el tercer día de la semana, en el turno de la noche. Esto nos permite abordar restricciones de requerimientos puntuales sobre el modelo.

Recordemos que el índice, tanto de operarios, turnos y días, comienza en 0. Por lo tanto, para efectos de la formulación de la restricción, el tercer día de la semana será el día 2 (los siete días de la semana son 0, 1, 2, 3, 4, 5 y 6); y el turno de la noche, será el turno 2 (turnos 0, 1 y 2 / mañana, tarde y noche).

Por otro lado, los operarios también son nombrados de acuerdo a sus índices: 0, 1, 2 y 3. Podemos arbitrariamente elegir el índice del operario aprendiz; en nuestro caso diremos que se trata del operario 0.

#Restricción del operario (o) 1 para trabajar el día (d) 2, en el turno (t) 2
model.Add(asignacion[(0, 2, 2)] != 1)

El operador != se utiliza para denotar diferente de, por lo tanto, la restricción indica que la asignación del operario 0, el día 2, en el turno 2, deberá ser diferente de 1; es decir que, al tratarse de una variable booleana, deberá ser Falso = 0.

Restricciones de turnos no programados (mantenimiento y limpieza)

De acuerdo al caso de aplicación, el último día de la semana se programan actividades de mantenimiento y limpieza, y que por lo tanto, solo se trabaja en el turno de la mañana. Por esta razón, debemos excluir a los turnos de la tarde y la noche de la programación (turnos 1 y 2) del último día (día 6).

Siguiendo con nuestras denominaciones algebraicas de ejemplo, tendríamos algo así:

X₀₆₁ + X₁₆₁ + X₂₆₁ + X₃₆₁ == 0

X₀₆₂ + X₁₆₂ + X₂₆₂ + X₃₆₂ == 0

Veamos cómo Python nos puede simplificar esta formulación de restricciones:

# Restricción de turnos no programados
model.Add(sum(asignacion[(o, 6, 1)] for o in total_operarios) == 0)
model.Add(sum(asignacion[(o, 6, 2)] for o in total_operarios) == 0)

Restricción de turnos mínimos programados

De acuerdo al caso de aplicación, debe programarse una cantidad de 19 turnos laborales. Es decir, la cantidad de turnos diarios (3) * la cantidad de días del programa (7); menos la cantidad de turnos no programados por mantenimiento y limpieza (2).

#Como mínimo deben trabajarse "turnos_laborales"
min_turnos_totales = []
for o in total_operarios:
    for d in total_dias:
        for t in total_turnos:
            min_turnos_totales.append(asignacion[(o, d, t)])
model.Add(sum(min_turnos_totales) >= turnos_laborales)

Esta restricción involucra a todas las variables de asignación del modelo, y por lo tanto el uso de ciclos es importante para simplificar el desarrollo de la formulación. Básicamente indica que la sumatoria de todas las variables de decisión (asignación) del modelo (que son booleanas, y para este efecto podemos decir que binarias), debe ser mayor o igual al mínimo de turnos laborales exigidos para programación.

La restricción es 1 sola, pero involucra las 84 variables de asignación.

Restricción de uniformidad en la distribución de turnos

El objetivo de estas restricciones es la de distribuir de la manera más uniforme posible los turnos asignados. En términos prácticos, el caso de aplicación indica que, no puede existir una diferencia mayor a un turno entre las asignaciones de los operarios. Es decir, ningún operario podrá tener asignados dos turnos más que otro operario, por ejemplo.

Para lograr esto es necesario realizar una serie de cálculos intermedios sencillos, con el objetivo de identificar: número de turnos asignables, cantidad mínima de turnos por operario, cantidad máxima de turnos por operario, entre otros.

min_turnos_por_operario = ((turnos * dias) - turnos_no_laborales) // operarios
if ((turnos * dias) - turnos_no_laborales) % operarios == 0:
    max_turnos_por_operario = min_turnos_por_operario
else:
    max_turnos_por_operario = min_turnos_por_operario + 1
for o in total_operarios:
    num_turnos_trabajados = []
    for d in total_dias:
        for t in total_turnos:
            num_turnos_trabajados.append(asignacion[(o, d, t)])
    model.Add(min_turnos_por_operario <= sum(num_turnos_trabajados))
    model.Add(sum(num_turnos_trabajados) <= max_turnos_por_operario)

Lo primero que hicimos fue calcular la parte entera de la fracción entre el número de turnos asignables y los operarios; lo que nos indica la cantidad mínima de turnos por operario. Veamos con un ejemplo:

(turnos * días) – turnos no laborales // operarios

(3 turnos por día * 7 días) – 2 turnos // 4 operarios

(3 * 7) – 2 // 4

19 // 4 = 4 turnos por operario

Esto indica que existe la posibilidad de asignar al menos 4 turnos por cada operario. Lo siguiente que se debe considerar es la cantidad máxima de turnos por operario.

En el caso en el cual la cantidad que resulte de dividir el número de turnos asignables entre el número de operarios sea entera sin decimales, esto indicaría que la distribución de los turnos puede realizarse en partes iguales, y por lo tanto la cantidad máxima de turnos por operario será equivalente a la cantidad mínima de turnos por operario.

En los casos en los que esto no ocurra, la cantidad máxima de turnos por operario será equivalente a la cantidad mínima de turnos por operario más 1. Recordemos que la restricción nos indica que la diferencia entre asignaciones de turnos a operarios no puede ser mayor de un turno.

Por todo lo demás, las restricciones de este paso consisten en establecer que la cantidad de turnos asignados por operario deberá ser mayor que la cantidad mínima de turnos por operario y deberá ser menor que a cantidad máxima de turnos por operario.

Paso 8: Crear el solucionador y enumerar las soluciones

# Creal (invocar) el solucionador y resolver
solver = cp_model.CpSolver()
solver.parameters.linearization_level = 0
# Enumerar las posibles soluciones
solver.parameters.enumerate_all_solutions = True

Paso 9: Configurar las salidas del modelo

Este paso consiste en configurar el formato de salida de las soluciones posibles. De forma arbitraria hemos determinado que se impriman las primeras 2 soluciones (solution_limit), de tal manera que el formato de salida tendrá la siguiente estructura:

• Solución i
  • Día d
    • Operario o, trabaja / no trabaja, en el turno t.

class OperariosParcialesSolucion(cp_model.CpSolverSolutionCallback):
    """Print intermediate solutions."""

    def __init__(self, asignacion, operarios, dias, turnos, limit):
        cp_model.CpSolverSolutionCallback.__init__(self)
        self._asignacion = asignacion
        self._operarios = operarios
        self._dias = dias
        self._turnos = turnos
        self._solution_count = 0
        self._solution_limit = limit

    def on_solution_callback(self):
        self._solution_count += 1
        print('Solución %i' % self._solution_count)
        for d in range(self._dias):
            print('Día %i' % d)
            for o in range(self._operarios):
                is_working = False
                for t in range(self._turnos):
                    if self.Value(self._asignacion[(o, d, t)]):
                        is_working = True
                        print('  Operario %i trabaja en el turno %i' % (o, t))
                if not is_working:
                    print('  Operario {} no trabaja'.format(o))
        if self._solution_count >= self._solution_limit:
            print('Detenga la búsqueda después de  %i soluciones' % self._solution_limit)
            self.StopSearch()

    def solution_count(self):
        return self._solution_count

# Muestra las primeras 2 soluciones.
solution_limit = 2
solution_printer = OperariosParcialesSolucion(asignacion, operarios, dias, turnos,
                                                    solution_limit)

Paso 10: Invocar al solucionador y configurar algunas estadísticas

Por último, nos queda invocar al solucionador, y configurar algunos datos estadísticos para enriquecer las salidas del modelo.

solver.Solve(model, solution_printer)

# Estadísticas.
print('\nEstadísticas')
print('  - conflictos      : %i' % solver.NumConflicts())
print('  - ramas de búsqueda       : %i' % solver.NumBranches())
print('  - tiempo de solución      : %f s' % solver.WallTime())
print('  - soluciones encontradas: %i' % solution_printer.solution_count())

Al ejecutar el programa completo, tendremos la siguiente salida:

• Solución 1
  • Día 0
    • Operario 0 no trabaja
    • Operario 1 trabaja en el turno 1
    • Operario 2 trabaja en el turno 2
    • Operario 3 trabaja en el turno 0
  • Día 1
    • Operario 0 no trabaja
    • Operario 1 trabaja en el turno 0
    • Operario 2 trabaja en el turno 2
    • Operario 3 trabaja en el turno 1
  • Día 2
    • Operario 0 trabaja en el turno 0
    • Operario 1 no trabaja
    • Operario 2 trabaja en el turno 2
    • Operario 3 trabaja en el turno 1
  • Día 3
    • Operario 0 trabaja en el turno 1
    • Operario 1 trabaja en el turno 0
    • Operario 2 trabaja en el turno 2
    • Operario 3 no trabaja
  • Día 4
    • Operario 0 trabaja en el turno 1
    • Operario 1 trabaja en el turno 0
    • Operario 2 no trabaja
    • Operario 3 trabaja en el turno 2
  • Día 5
    • Operario 0 trabaja en el turno 2
    • Operario 1 trabaja en el turno 0
    • Operario 2 no trabaja
    • Operario 3 trabaja en el turno 1
  • Día 6
    • Operario 0 trabaja en el turno 0
    • Operario 1 no trabaja
    • Operario 2 no trabaja
    • Operario 3 no trabaja
• Solución 2
  • Día 0
    • Operario 0 no trabaja
    • Operario 1 trabaja en el turno 1
    • Operario 2 trabaja en el turno 2
    • Operario 3 trabaja en el turno 0
  • Día 1
    • Operario 0 no trabaja
    • Operario 1 trabaja en el turno 0
    • Operario 2 trabaja en el turno 2
    • Operario 3 trabaja en el turno 1
  • Día 2
    • Operario 0 trabaja en el turno 0
    • Operario 1 no trabaja
    • Operario 2 trabaja en el turno 2
    • Operario 3 trabaja en el turno 1
  • Día 3
    • Operario 0 trabaja en el turno 1
    • Operario 1 trabaja en el turno 0
    • Operario 2 trabaja en el turno 2
    • Operario 3 no trabaja
  • Día 4
    • Operario 0 trabaja en el turno 1
    • Operario 1 trabaja en el turno 0
    • Operario 2 no trabaja
    • Operario 3 trabaja en el turno 2
  • Día 5
    • Operario 0 trabaja en el turno 1
    • Operario 1 trabaja en el turno 0
    • Operario 2 no trabaja
    • Operario 3 trabaja en el turno 2
  • Día 6
    • Operario 0 trabaja en el turno 0
    • Operario 1 no trabaja
    • Operario 2 no trabaja
    • Operario 3 no trabaja

Detenga la búsqueda después de 2 soluciones

Estadísticas
– conflictos : 973
– ramas de búsqueda : 1730
– tiempo de búsqueda : 0.044052 s
– soluciones encontradas: 2

Hemos formulado un modelo con 84 variables de decisión, 55 restricciones y algunos cálculos intermedios. Podemos observar cómo el modelo ha logrado encontrar soluciones que satisfacen las restricciones planteadas (formuladas). Del mismo modo, podemos observar el tiempo en el cual ha logrado el solucionador hallar la cantidad de soluciones solicitadas (fracciones de segundo).

Es interesante percibir las bondades de este tipo desarrollos, y considerar las posibilidades de aplicación en otros campos diferentes a la programación de empleados; teniendo en cuenta la flexibilidad de la programación basada en restricciones, la potencia de los solucionadores y la capacidad de procesamiento de los equipos en la actualidad.

El código completo de este desarrollo lo puedes encontrar en nuestro cuaderno: Programación de empleados.

La entrada Programación de empleados mediante programación entera se publicó primero en Ingenieria Industrial Online.

Tal como lo hemos abordado ampliamente, una de las aplicaciones más importantes del modelamiento de Cadenas de Suministro, es el diseño de red de abastecimiento, y dentro de esta categoría, el diseño de rutas de transporte (enrutamiento de vehículos).

Los problemas de enrutamiento de vehículos (routing), se encuentran clasificados como problemas de optimización combinatoria, y esto producto de que la cantidad de rutas posibles en un modelo básico, se encuentra determinado por la ecuación (n – 1)!, donde n, es igual al número de ubicaciones que componen el problema de enrutamiento.

Ahora bien, no solo la resolución de los problemas de enrutamiento es considerada como compleja, también lo es la fase preliminar en la que debemos levantar la información de entrada del modelo (inputs), específicamente, la matriz de distancias.

La forma más básica de un modelo VRP, requiere para su resolución la siguiente información mínima de entrada:

La matriz de distancias es un tabulado que registra la longitud entre cada uno de los nodos del modelo, incluido el nodo depósito. Su tamaño será n x n (siendo n el número de nodos del modelo). Asumiendo, por ejemplo, que tenemos un problema que se compone de 1 depósito y 19 ubicaciones, el modelo requerirá de una matriz de distancias con 400 datos.

En artículos anteriores hemos abordado modelos robustos para la resolución de problemas VRP y algunas de sus extensiones (CVRP, por ejemplo). El objetivo de este artículo será la de utilizar funciones espaciales de Python, para obtener una matriz de distancias de acuerdo a ubicaciones reales, con el propósito de resolver un modelo VRP básico.

Caso de aplicación

La Secretaría de Educación de Santiago de Cali, tiene dentro de sus funciones, distribuir el material pedagógico a las diferentes instituciones de formación de la ciudad. La distribución del material se realiza todos los lunes, y para ello, la Secretaría cuenta con dos vehículos con capacidad suficiente para transportar todo el material. El depósito del material (lugar desde donde salen y deben regresar los vehículos), se encuentra en la Alcaldía de Cali; y las instituciones que deben visitarse son 60. Tal como podemos apreciar en la siguiente tabla:

Se desea desarrollar un plan de rutas para cada uno de los vehículos que logre minimizar la distancia total recorrida, al tiempo que asegure la visita de todos los colegios.

¿Qué necesitaremos?

En el desarrollo de este ejercicio emplearemos:

Paso 1: Crear el entorno de trabajo en Colaboratory

Lo primero que vamos a hacer consiste en crear un entorno de trabajo en Google Colaboratory, así que vayamos allá: Abrir cuaderno nuevo.

Verán que tienen un lienzo para programar el modelo, así que en este cuaderno podemos ir generando las líneas de código que explicaremos en los pasos siguientes.

Paso 2: Importar las librerías necesarias

Respecto a las librerías, en la introducción del artículo hicimos una descripción de la funcionalidad de cada una, veamos como importarlas en nuestro entorno:

from sklearn.neighbors import DistanceMetric
from math import radians
import pandas as pd
import numpy as np

De esta manera, tenemos todo lo necesario para empezar a desarrollar nuestro código.

Paso 3: Importar los datos desde Excel

De acuerdo a las necesidades del modelo, podemos desarrollar un código que permita la entrada manual de la información, la captura de los datos desde entornos digitales (Internet, por ejemplo), o podemos, desde luego, alimentar nuestro modelo con información contenida en documentos externos, como es el caso de un archivo de Microsoft Excel.

Esta puede considerarse como una de las ventajas de utilizar Python, su capacidad de integrarse con cualquier fuente de datos. En nuestro caso, toda la información se encuentra contenida en un documento de Excel, el cual presenta el siguiente formato:

Utilizaremos ubicaciones reales, y para eso emplearemos las coordenadas de latitud y longitud.

En Colaboratory, el siguiente fragmento permitirá cargar un archivo al entorno de ejecución:

from google.colab import files

uploaded = files.upload()

for fn in uploaded.keys():
  print('User uploaded file "{name}" with length {length} bytes'.format(
      name=fn, length=len(uploaded[fn])))

Al ejecutar este fragmento de código, se abrirá una ventana emergente del explorador que permitirá cargar nuestra base de datos, en nuestro caso el archivo tienen el nombre de colegios.xlsx.

La siguiente línea de código permitirá almacenar los datos contenidos en el documento en un Dataframe de nuestro entorno, dentro de la variable data.

#Leer el documento de Excel y almacenar los datos en la variable data
data = pd.read_excel('colegios.xlsx')

Podemos en cualquier momento confirmar si la carga de los datos se ha realizado correctamente, para eso imprimiremos las primeras cinco filas del  DataFrame:

data.head()

Al ejecutar esta instrucción tenemos la siguiente salida (Una vista de las 5 primeras filas del marco de datos):

Podemos observar que los datos han sido perfectamente cargados, y que ahora se encuentran almacenados en la variable (DataFrame): data.

Paso 4: Convertir las coordenadas de latitud y longitud en radianes

La mayor parte de las funciones de cálculo de distancias de Sklearn (Scipy) toman las entradas como radianes. Por esta razón, debemos convertir las coordenadas en radianes.

data['Latitud'] = np.radians(data['Latitud'])
data['Longitud'] = np.radians(data['Longitud'])

#Creamos una matriz bidimensional con la latitud y la longitud en radianes
data[['Latitud','Longitud']].to_numpy()

Al ejecutar estas líneas, las coordenadas quedarán convertidas en radianes.

Paso 5: Declarar el tipo de métrica de distancias que se utilizará

En este punto quiero detenerme para mencionar que existen decenas de funciones métricas de distancia rápida. Algunas de las más utilizadas son destinadas a espacios vectoriales de valor real, como: distancias euclidianas, distancias de Manhattan, etc. Prácticas cuando se emplean con coordenadas cartesianas.

En nuestro caso, ya que utilizamos ubicaciones reales y contamos con coordenadas de latitud y de longitud, podemos emplear una función de distancia de vectores bidimensionales que considere la curvatura de la tierra; tal es el caso de las Distancias Haversine (Semiverseno).

Si quieren conocer la fórmula empleada para el cálculo de cada distancia haversine:

Para efectos de nuestro desarrollo, utilizaremos la librería SKLearn para calcular nuestras distancias. Veamos:

dist = DistanceMetric.get_metric('haversine')

dist.pairwise(data[['Latitud','Longitud']].to_numpy())*6373

El fragmento anterior crea un objeto con métricas haversine, y luego utiliza la función pairwise(), para calcular la distancia entre cada uno de los elementos de la matriz (nodos). Cada distancia calculada multiplica el escalar 6373 (radio esférico de la tierra), para calcular las distancias en kilómetros (Para millas multiplicar por 3798).

Paso 6: Crear un marco de datos (tabulado) de matriz de distancias

Una vez que ejecutemos el paso anterior, tendremos nuestras distancias entre nodos calculadas; lo que haremos en este paso será organizar dichos valores en forma de marco de datos o tabulado, obteniendo nuestra matriz de distancias.

distance_matrix = pd.DataFrame(dist.pairwise(data[['Latitud','Longitud']].to_numpy())*6373)

distance_matrix.head()

Al ejecutar esta instrucción tenemos la siguiente salida (Una vista de las 5 primeras filas del marco de datos):

Podemos imprimir la matriz completa:

print(distance_matrix)

Hasta este punto hemos logrado nuestro objetivo principal, que era obtener una matriz de distancias de forma automática tomando como base las coordenadas de longitud y latitud de un conjunto de nodos. Específicamente hemos obtenido 3721 valores de distancia en cuestión de segundos (empleando la métrica haversine).

Lógicamente, estos valores de referencia en la práctica presentan algunas desventajas, como, por ejemplo, la dificultad subyacente de atravesar las ciudades por lugares diferentes que las vías dispuestas para ello. Sin embargo, estos valores pueden ser muy útiles como datos de entrada de un modelo VRP para obtener la secuencia del plan de rutas.

Lo siguiente que haremos, para finalizar nuestro caso de aplicación, será utilizar la matriz de distancias obtenida, en un modelo VRP básico (Si desea profundizar en el modelo, visite el artículo).

Paso 7: Instalar Google Or Tools

Es necesario instalar la librería de Google Or Tools en nuestro entorno de Colaboratory para poder utilizar nuestro modelo VRP.

!pip install ortools

Al ejecutar esta instrucción instalaremos nuestro solucionador del modelo de enrutamiento.

Paso 8: Incorporar el modelo VRP (Previamente formulado)

Como ya lo mencionamos, contamos con un modelo debidamente formulado para resolver problemas VRP básicos. Lo único que modificaremos serán los datos de entrada: Matriz de distancias (distance_matrix), Número de vehículos (2), Depósito (Nodo 0).

"""Problema de enrutamiento de vehículos simple (VRP)

Autor: MSc. Ing. Bryan Salazar López 2021

"""

from ortools.constraint_solver import routing_enums_pb2
from ortools.constraint_solver import pywrapcp


def create_data_model():
    """Datos de entrada del modelo"""
    #Llamaremos la matriz de distancia previamente obtenida
    #Emplearemos dos vehículos como lo indica el problema
    #Definiremos el nodo 0 como el depósito (Secretaría)
    data = {}
    data['matriz_distancias'] = distance_matrix
    data['num_vehiculos'] = 2
    data['deposito'] = 0
    return data


def print_solution(data, manager, routing, solution):
    """Imprime la solución sobre la consola"""
    max_route_distance = 0
    for vehicle_id in range(data['num_vehiculos']):
        index = routing.Start(vehicle_id)
        plan_output = 'Ruta para el vehículo {}:\n'.format(vehicle_id)
        route_distance = 0
        while not routing.IsEnd(index):
            plan_output += ' {} -> '.format(manager.IndexToNode(index))
            previous_index = index
            index = solution.Value(routing.NextVar(index))
            route_distance += routing.GetArcCostForVehicle(
                previous_index, index, vehicle_id)
        plan_output += '{}\n'.format(manager.IndexToNode(index))
        plan_output += 'Distancia de la ruta: {}km\n'.format(route_distance)
        print(plan_output)
        max_route_distance += route_distance
        max_route_distance = max(route_distance, max_route_distance)
    print('Distancia total de todas las rutas: {}km'.format(max_route_distance))



def main():
    """Punto de entrada del programa"""
    # Invocar la data de entrada.
    data = create_data_model()

    # Crea el administrador del índice de rutas.
    manager = pywrapcp.RoutingIndexManager(len(data['matriz_distancias']),
                                           data['num_vehiculos'], data['deposito'])

    # Crea el modelo de enrutamiento.
    routing = pywrapcp.RoutingModel(manager)


    # Crea y registra una devolución de llamada de distancia.
    def distance_callback(from_index, to_index):
        """Retorna la distancia entre dos nodos."""
        # Convierte desde la variable de ruta Index hasta la matriz de distancia NodeIndex.
        from_node = manager.IndexToNode(from_index)
        to_node = manager.IndexToNode(to_index)
        return data['matriz_distancias'][from_node][to_node]

    transit_callback_index = routing.RegisterTransitCallback(distance_callback)

    # Define el costo de cada arco.
    routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)

    # Adhiere la dimensión de distancia.
    dimension_name = 'Distancia'
    routing.AddDimension(
        transit_callback_index,
        0,  # Sin holgura
        3000,  # Distancia máxima de viaje del vehículo
        True,  # Iniciar el acumulador en cero
        dimension_name)
    distance_dimension = routing.GetDimensionOrDie(dimension_name)
    distance_dimension.SetGlobalSpanCostCoefficient(100)

    # Configurar los parámetros de búsqueda.
    search_parameters = pywrapcp.DefaultRoutingSearchParameters()
    search_parameters.first_solution_strategy = (
        routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)

    # Solucionador del problema.
    solution = routing.SolveWithParameters(search_parameters)

    # Imprimir la solución en la consola.
    if solution:
        print_solution(data, manager, routing, solution)
    else:
        print('No se encuentra solución !')


if __name__ == '__main__':
    main()

Al ejecutar el modelo tendremos:

Un plan de rutas para los dos vehículos que parten desde los depósitos (ahí mismo finalizan sus recorridos), y visitan la totalidad de los nodos. La distancia total optimizada es equivalente a 33 km.

Por último, también es posible exportar la matriz de distancias que hemos obtenido, para eso utilizaremos el siguiente fragmento:

distance_matrix.to_csv('distance_matrix.csv')
files.download('distance_matrix.csv')

El código completo de este desarrollo lo puedes encontrar en nuestro cuaderno: Matriz de distancias para modelar un VRP.

La entrada ¿Cómo calcular una matriz de distancias para modelar un VRP? se publicó primero en Ingenieria Industrial Online.

Para entender de qué se trata el método de Ruta Crítica, y cómo funciona como un algoritmo de redes, podemos dirigirnos a: Método de la Ruta Crítica (CPM). De acuerdo al objetivo de este artículo, basta con mencionar que la Ruta Crítica es una herramienta que soporta el análisis, la planificación, y la programación de proyectos. Que básicamente, nos ayuda a determinar cuáles de las actividades que componen un proyecto, son críticos con relación en su efecto sobre el tiempo total del proyecto.

El objetivo de este artículo es el de, mediante herramientas tecnológicas, abordar un caso básico de CPM, para desarrollar el método utilizando un lenguaje de programación, en este caso Python, que nos permita, automatizar los cálculos y así obtener las actividades críticas del proyecto, la duración del mismo y un diagrama de Gantt.

En el desarrollo de este ejercicio emplearemos:

Para evaluar los resultados obtenidos a través del tratamiento de un problema técnicamente formulado y abordado, utilizaremos un caso descrito en el libro Investigación de Operaciones (9na edición), de Hamdy A. Taha (University of Arkansas, Fayetteville), (Ejemplo 6.5-1):

Caso de aplicación

Un editor firmó un contrato con un autor para publicar un libro de texto. El autor somete a consideración una copia impresa de un archivo de computadora del manuscrito. Las actividades (simplificadas) asociadas con la producción del libro de texto se resumen en la siguiente tabla.

La tarea será determinar la Ruta Crítica (Actividades críticas) y la duración estimada del proyecto.

Paso 1: Crear el entorno de trabajo en Colaboratory

Lo primero que vamos a hacer consiste en crear un entorno de trabajo en Google Colaboratory, así que vayamos allá: Abrir cuaderno nuevo.

Verán que tienen un lienzo para programar el modelo, así que en este cuaderno podemos ir generando las líneas de código que explicaremos en los pasos siguientes.

Paso 2: Importar las librerías necesarias

Respecto a las librerías, en la introducción del artículo hicimos una descripción de la funcionalidad de cada una, veamos como importarlas en nuestro entorno:

#Importar las librerías necesarias
!pip install criticalpath
from criticalpath import Node
import datetime
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.patches import Patch
import numpy as np

De esta manera, tenemos todo lo necesario para empezar a desarrollar nuestro código.

Paso 3: Ingresar los datos del modelo

Básicamente los datos del modelo corresponden a las tareas, su duración y las relaciones de dependencia que rigen la secuencia del proyecto.

El siguiente fragmento permite ingresar estos datos al modelo:

#Ingresar los datos del modelo (Tareas y dependencias)

#Crear el proyecto "p"
p = Node('proyecto')

tareas = [("A", {"duracion": 3}), 
          ("B", {"duracion": 2}), 
          ("C", {"duracion": 4}), 
          ("D", {"duracion": 3}), 
          ("E", {"duracion": 2}), 
          ("F", {"duracion": 4}), 
          ("G", {"duracion": 2}), 
          ("H", {"duracion": 1}), 
          ("I", {"duracion": 2}), 
          ("J", {"duracion": 4})]

dependencias = [("A", "E"), 
                ("B", "E"), 
                ("E", "F"),
                ("F", "G"), 
                ("G", "I"), 
                ("I", "J"),
                ("C", "J"), 
                ("H", "I"), 
                ("D", "H")]

# Cargar al proyecto las tareas y sus duraciones
for i in tareas:
    p.add(Node(i[0], duration=i[1]["duracion"]))

# Cargar al proyecto sus dependencias (secuencias)
for j in dependencias:
    p.link(j[0],j[1])

# Actualizar el proyecto:
p.update_all()

El anterior fragmento nos permite cargar todos los datos necesarios para conocer la Ruta Crítica del modelo. Veamos cómo obtenerla:

#Obtener la Ruta Crítica del modelo
p.get_critical_path()

Al ejecutar esta instrucción tenemos la siguiente salida:

De la misma manera, podemos obtener la duración estimada del proyecto:

#Obtener la duración del proyecto
p.duration

Al ejecutar esta instrucción tenemos la siguiente salida:

Así entonces, de esta manera muy sencilla tenemos las actividades que componen la Ruta Crítica y la duración del proyecto de acuerdo a CPM (17 semanas). Podríamos finalizar el modelo hasta acá, sin embargo, queremos obtener el diagrama de Gantt del proyecto, y para eso es necesario obtener algunas variables adicionales.

Paso 4: Obtener las variables de inicio y finalización

Ya que el problema planteado no establece fechas de inicio y finalización, podemos, mediante Python, utilizar una fecha de inicio artificial, por ejemplo: Hoy. ¿Con qué objetivo hacemos esto? Los diagramas de Gantt requieren de una línea de tiempo y es preciso establecer estas variables. Estableceremos fechas de inicio, de finalización y un status para cada actividad del proyecto.

En este caso puntual, ya que la duración de cada actividad se nos da en semanas, multiplicaremos el valor de la duración por 7:

#Obtener las variables de inicio y finalización
ruta_critica = [str(n) for n in p.get_critical_path()]

proj_fecha_inicio = datetime.date.today()

proj_calendario = pd.DataFrame([dict(Tarea = key, 
                                   Inicio = datetime.date.today(), 
                                   Fin = datetime.date.today() + datetime.timedelta(val['duracion']*7), 
                                   Status = 'Actividad Normal')
                              for key, val in dict(tareas).items()])

for key, val in dict(tareas).items():
    dep = [d for d in dependencias if d[1] == key]
    prev_tareas = [t[0] for t in dep]
    if prev_tareas:
        prev_fin = proj_calendario[proj_calendario.Tarea.isin(prev_tareas)]['Fin'].max()
        proj_calendario.loc[proj_calendario.Tarea == key, 'Inicio'] = prev_fin
        proj_calendario.loc[proj_calendario.Tarea == key, 'Fin'] = prev_fin + datetime.timedelta(val['duracion']*7)
        
proj_calendario.loc[proj_calendario.Tarea.isin(ruta_critica), 'Status'] = 'Ruta Crítica'
        
display(proj_calendario)

Al ejecutar este fragmento de código, tendremos:

Podemos apreciar cómo tenemos las fechas estimadas de inicio de cada actividad y su correspondiente fecha de finalización (teniendo en cuenta que la duración de las actividades está dada en semanas). También tenemos un status relacionado con la naturaleza de cada actividad: Crítica o Normal.

Y tenemos fechas de inicio y finalización, lo siguiente será calcular cuántos días pasan entre el inicio del proyecto y el inicio y finalización de cada actividad:

# Número de días desde que el proyecto inicia hasta que la tarea inicia
proj_calendario['dias_inicio'] = (proj_calendario.Inicio-proj_fecha_inicio).dt.days
# Número de días desde que el proyecto inicia hasta que la tarea finaliza
proj_calendario['dias_fin'] = (proj_calendario.Fin-proj_fecha_inicio).dt.days
# Días entre el inicio y el fin de cada tarea
proj_calendario['dias_inicio_fin'] = proj_calendario.dias_fin - proj_calendario.dias_inicio

display(proj_calendario)

Al ejecutar este fragmento de código, tendremos:

Paso 5: Obtener el diagrama de Gantt (Graficar)

El siguiente paso consiste en graficar de acuerdo al diagrama de Gantt, ls actividades del proyecto. El eje x estará dado en días.

#Graficar las actividades en un diagrama de Gantt
fig, ax = plt.subplots(1, figsize=(16,6))
ax.barh(proj_calendario.Tarea, proj_calendario.dias_inicio_fin, left=proj_calendario.dias_inicio)
plt.show()

Al ejecutar el fragmento tendremos:

Paso 6: Mejorar el diagrama de Gantt

Una vez obtenido el diagrama podemos realizar modificaciones sobre el mismo, por ejemplo: dar un color específico a las actividades de la ruta crítica, anexar leyendas, entre otros. Vamos a resaltar con rojo las actividades críticas, y a anexar alguna leyenda de actividades:

# Dar color rojo a las columnas de actividades críticas
def color(row):
    c_dict = {'Ruta Crítica':'#E64646', 'Actividad Normal':'#4F81BE'}
    return c_dict[row['Status']]
proj_calendario['color'] = proj_calendario.apply(color, axis=1)
fig, ax = plt.subplots(1, figsize=(16,6))
ax.barh(proj_calendario.Tarea, proj_calendario.dias_inicio_fin, left=proj_calendario.dias_inicio, color=proj_calendario.color)

#Anexar leyendas
c_dict = {'Ruta crítica':'#E64646', 'Actividad normal':'#4F81BE'}
leyenda = [Patch(facecolor=c_dict[i], label=i)  for i in c_dict]
plt.legend(handles=leyenda)

plt.show()

Al ejecutar el fragmento tendremos:

Ahora tenemos un modelo capaz de obtener las actividades críticas de un proyecto, determinar su duración de acuerdo al algoritmo CPM y graficar las actividades mediante un diagrama de Gantt.

También es posible incorporar una variable de «estado de terminación» de cada actividad, para así observar el avance del proyecto.

El código completo de este desarrollo lo puedes encontrar en nuestro cuaderno: Método de la Ruta Crítica (CPM) mediante Python.

La entrada Método de la Ruta Crítica mediante Python (CPM) se publicó primero en Ingenieria Industrial Online.

En un artículo anterior, desarrollamos un modelo capaz de determinar la localización de una instalación (almacén), de acuerdo a un conjunto de ubicaciones existentes (clientes); estas ubicaciones tenían una ponderación determinada (peso, por ejemplo demanda), y basamos nuestro desarrollo en el algoritmo de Centro de Gravedad.

El valor agregado del modelo consistía en la integración de una capa de mapa de calor (para graficar la densidad), un proceso de geocodificación y el uso de un entorno geográfico real. El alcance de este modelo se encuentra determinado por la localización de una sola instalación (depósito, almacén, etc.), y en los casos en los que se requiera determinar múltiples localizaciones, el modelo no aplica.

La pregunta siguiente que nos hacemos es ¿Cómo determinar la localización de múltiples instalaciones? En realidad, hay muchas respuestas para este interrogante, y gran parte de ellas conducen a la agrupación geoespacial (Clustering).

¿Qué es la agrupación geoespacial (Clustering)?

La agrupación geoespacial es un método que se utiliza para asociar un conjunto de objetos espaciales en grupos denominados «clusters«. Los objetos que conforman cada grupo presentan un grado de similitud asociado a un atributo o varios atributos en particular.

El objetivo de la agrupación geoespacial, consiste en determinar una relación entre atributos espaciales (coordenadas, ubicación) y no espaciales (demanda, por ejemplo).

En la literatura encontraremos varios tipos de agrupación geoespacial, cada uno con un enfoque particular, y un campo de aplicación específico; entre los cuales podemos encontrar:

En nuestro caso, que pretendemos determinar la localización de varias instalaciones, considerando la ponderación y ubicación de los puntos existentes, requerimos de un modelo capaz de relacionar atributos espaciales (coordenadas) y no espaciales (peso de cada nodo). Que nos permita, primero agrupar los puntos dados (ubicaciones), y eventualmente, aplicar un algoritmo de Centro de Gravedad, para determinar localizaciones potenciales.

Para tales efectos, vamos a utilizar la agrupación de particiones, que se caracteriza, entre otras, por:

Vale la pena destacar que en cuanto a la agrupación de participaciones, en esta categoría encontraremos varios métodos de partición, y nosotros utilizaremos el método K-Means, un algoritmo de aprendizaje automático (Machine Learning) no supervisado. Para ello utilizaremos Python.

Para sintetizar, el objetivo de este artículo será el de emplear un algoritmo de aprendizaje automático capaz de agrupar nuestros nodos en clusters, de acuerdo a atributos espaciales (coordenadas) y no espaciales (ponderación); para luego, utilizar un algoritmo de Centro de Gravedad en cada clúster para determinar la localización de múltiples instalaciones (almacenes, depósitos, etc.).

En el desarrollo de este ejercicio emplearemos:

Para desarrollar estas herramientas, vamos a plantear un caso típico de localización de múltiples instalaciones a partir de la consideración de otros nodos (nodos de demanda, por ejemplo).

Caso de aplicación

El Departamento de Desarrollo Sostenible de la ciudad de Cali se encuentra implementando una estrategia piloto de recolección de aceite de cocina usado. Ha articulado este proyecto con una Universidad, la cual desarrolló 4 contenedores inteligentes (BIN’s) para la disposición del bioresiduo.

En investigaciones asociadas, la Universidad ha determinado que el reciclaje del aceite es un problema de densidad; esto quiere decir que es vital la ubicación de los contenedores (cobertura), para así mismo optimizar el proceso de disposición y recolección. El proyecto piloto piensa articular a las instituciones de educación como puntos potenciales de recolección. Por medio de las instituciones piensan socializar el programa con la comunidad. El primer reto del proyecto consiste en determinar la ubicación de los contenedores inteligentes (4 unidades). La información relacionada con las instituciones de educación que hacen parte del programa (ubicación geográfica / población estudiantil), se detalla a continuación:

Para tales efectos, desarrollaremos un modelo que apoye el análisis preliminar y la localización de los múltiples contenedores. También, que tenga la capacidad de predecir el grupo (clúster) al que pertenecería un nodo nuevo.

Paso 1: Crear el entorno de trabajo en Colaboratory

Lo primero que vamos a hacer consiste en crear un entorno de trabajo en Google Colaboratory, así que vayamos allá: Abrir cuaderno nuevo.

Verán que tienen un lienzo para programar el modelo, así que en este cuaderno podemos ir generando las líneas de código que explicaremos en los pasos siguientes.

Paso 2: Importar las librerías necesarias

Respecto a las librerías, en la introducción del artículo hicimos una descripción de la funcionalidad de cada una, veamos como importarlas en nuestro entorno:

#Importar las librerías necesarias
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

De esta manera, tenemos todo lo necesario para empezar a desarrollar nuestro código.

Paso 3: Importar los datos desde Excel

De acuerdo a las necesidades del modelo, podemos desarrollar un código que permita la entrada manual de la información, la captura de los datos desde entornos digitales (Internet, por ejemplo), o podemos, desde luego, alimentar nuestro modelo con información contenida en documentos externos, como es el caso de un archivo de Microsoft Excel.

Esta puede considerarse como una de las ventajas de utilizar Python, su capacidad de integrarse con cualquier fuente de datos. En nuestro caso, toda la información se encuentra contenida en un documento de Excel, el cual presenta el siguiente formato:

Ya veremos cómo, parte de estos datos son prescindibles y otros indispensables.

En Colaboratory, el siguiente fragmento permitirá cargar un archivo al entorno de ejecución:

from google.colab import files

uploaded = files.upload()

for fn in uploaded.keys():
  print('User uploaded file "{name}" with length {length} bytes'.format(
      name=fn, length=len(uploaded[fn])))

Al ejecutar este fragmento de código, se abrirá una ventana emergente del explorador que permitirá cargar nuestra base de datos, en nuestro caso el archivo tienen el nombre de cluster.xlsx.

La siguiente línea de código permitirá almacenar los datos contenidos en el documento en un Dataframe de nuestro entorno, dentro de la variable data.

#Leer el documento de Excel y almacenar los datos en la variable data
data = pd.read_excel('cluster.xlsx')

Podemos en cualquier momento confirmar si la carga de los datos se ha realizado correctamente, para eso imprimiremos las primeras cinco filas del  DataFrame:

data.head()

Al ejecutar esta instrucción tenemos la siguiente salida:

Paso 4: Graficar los puntos dados iniciales (Nodos)

Nuestros puntos iniciales, o las ubicaciones de partida son las instituciones de educación que nos otorga el planteamiento del problema.

Para graficar estos puntos utilizamos el sistema de coordenadas disponible: Latitud y Longitud. Así entonces, debemos extraer estos datos de la hoja de cálculo (DataFrame) que hemos importado al modelo; convertir estas coordenadas en una matriz bidimensional (Latitud y Longitud) y graficar los puntos:

#Graficar los nodos dados (ubicaciones)
Lat= data['Latitud']
Lon = data['Longitud']
Peso = data['Peso']
X = []
for i in range(len(data['Latitud'])):
    X.append(Lat[i])
    X.append(Lon[i])

X = np.array(X)

X = X.reshape(-1, 2,)


plt.scatter(Lat, Lon)
plt.show()

Al ejecutar este fragmento de código, tendremos:

Podemos apreciar cómo se encuentran dispersos los nodos iniciales, formando parte un mismo conjunto que es la población. Las coordenadas son latitud y longitud. Los nodos son, una vez más recordamos, las instituciones educativas, de acuerdo al caso de estudio.

Paso 5: Agrupar los nodos geoespacialmente mediante Machine Learning

Cuando mencionamos Machine Learning, a menudo la primera consideración que tenemos es de complejidad. Pues bien, muchos de los algoritmos que hemos utilizado durante décadas son en realidad de aprendizaje automático, como por ejemplo la regresión lineal. El algoritmo de K-Means que emplearemos de forma automatizada mediante Python, utiliza centroides que minimizan la inercia, o el criterio de suma de cuadrados de cada clúster:

Me pareció conveniente explicar un poco la teoría, pero vayamos a la práctica. Toda vez que tenemos los nodos del modelo, lo siguiente que debemos indicar es la cantidad de agrupaciones que queremos (clúster). Ya que el problema plantea la disposición de 4 contenedores, vamos a dividir la población de nodos en 4 conjuntos.

Luego, correremos el algoritmo K-Means, veamos cómo:

#Ejecutar el algoritmo KMeans
clusters = 4
KMean = KMeans(n_clusters=clusters)
KMean_g = KMean.fit_predict(X)
KMean.fit(X)

Lo siguiente que haremos será establecer los centroides de cada clúster, es decir, la ubicación de nuestros contendores. En primer lugar, el modelo nos dará las coordenadas. Utilizaremos la siguiente línea de código:

#Determinar los centroides de cada clúster
KMean.cluster_centers_

Al ejecutarla tendremos:

Estas son las coordenadas que indican el centro de cada uno de nuestros grupos de nodos. Y teóricamente ahí deberíamos disponer nuestros contenedores.

Paso 6: Graficar los clusters y los centroides (Localizaciones múltiples)

El siguiente paso consiste en graficar todas las coordenadas que ya tenemos: tantos los nodos iniciales, como los los centroides, o las localizaciones solución. Veamos cómo:

#Graficar todas las coordenadas (Puntos y centroides)
plt.scatter(X[:,0], X[:,1], c=KMean_g) #Puntos iniciales

#Centroides
plt.scatter(KMean.cluster_centers_[0][0], KMean.cluster_centers_[0][1], s=50, c='r')
plt.scatter(KMean.cluster_centers_[1][0], KMean.cluster_centers_[1][1], s=50, c='r')
plt.scatter(KMean.cluster_centers_[2][0], KMean.cluster_centers_[2][1], s=50, c='r')
plt.scatter(KMean.cluster_centers_[3][0], KMean.cluster_centers_[3][1], s=50, c='r')

Al ejecutar el fragmento tendremos:

Vemos cómo se han efectuado las agrupaciones de los nodos (colores), y los marcadores rojos indican los centroides. Este debería ser el final de nuestro desarrollo, sin embargo, no sé si lo han notado, siempre hemos hablado de centroides, nunca de centros de gravedad o centros de masa. Bien, no sé si también han identificado que en ningún momento hemos considerado el peso de cada nodo, en este caso la población estudiantil de cada institución.

¿Esto qué implica? Implica que hemos desarrollado un modelo que tiene exclusivamente consideraciones espaciales. De hecho, visualmente puede observarse cómo, básicamente los centroides se ubican en lo que podría considerarse el medio de cada clúster, sin ninguna consideración adicional aparente, por lo menos a la vista.

Pues bien, vamos a solucionarlo, para ello debemos retocar algunos de los pasos anteriores:

Paso 5 (Recargado): Agrupar los nodos geoespacialmente mediante Machine Learning (Considerando atributos espaciales y no espaciales)

Dentro de nuestro marco de datos (DataFrame) tenemos la información relacionada al peso de cada nodo (Población estudiantil). Pues bien, vamos a considerarla al ejecutar el algoritmo K-Means.

#Ejecutar el algoritmo KMeans (Considerando el peso de los nodos)
clusters = 4
KMean = KMeans(n_clusters=clusters)
KMean_g = KMean.fit_predict(X)
KMean.fit(X, sample_weight=Peso)

Lo siguiente que haremos será establecer los centroides de cada clúster, que ahora sí serán Centros de Gravedad; es decir, la ubicación de nuestros contendores. En primer lugar, el modelo nos dará las coordenadas. Utilizaremos la siguiente línea de código:

#Determinar los centroides de cada clúster
KMean.cluster_centers_

Al ejecutarla tendremos:

Los centroides han cambiado, ahora son centros de gravedad afectados por el peso de cada nodo. Es posible que incluso haya cambiado la agrupación de los nodos (composición de los clusters).

Paso 6 (Recargado): Graficar los clusters y los Centros de Gravedad (Localizaciones múltiples)

El siguiente paso consiste en graficar todas las coordenadas que ya tenemos: tantos los nodos iniciales, como los los Centros de Gravedad, o las localizaciones solución. Veamos cómo:

#Graficar todas las coordenadas (Puntos y centroides)
plt.scatter(X[:,0], X[:,1], c=KMean_g) #Puntos iniciales

#Centroides
plt.scatter(KMean.cluster_centers_[0][0], KMean.cluster_centers_[0][1], s=50, c='r')
plt.scatter(KMean.cluster_centers_[1][0], KMean.cluster_centers_[1][1], s=50, c='r')
plt.scatter(KMean.cluster_centers_[2][0], KMean.cluster_centers_[2][1], s=50, c='r')
plt.scatter(KMean.cluster_centers_[3][0], KMean.cluster_centers_[3][1], s=50, c='r')

Al ejecutar el fragmento tendremos:

El resultado respecto a los centroides es diferente. La consideración de un atributo no espacial, en este caso el peso de cada nodo (población estudiantil de cada institución educativa), ha incidido en la ubicación propuesta de las localizaciones solución. Y este debería ser el final de nuestro modelo.

Hemos logrado agrupar nuestros puntos iniciales en clusters, y luego hemos determinado los Centros de Gravedad de cada uno de los clusters.

Por último, veamos una característica de la librería K-Means Análisis predictivo de nodos en clusters, es decir, de acuerdo a unas coordenadas dadas, podemos estimar el grupo al que pertenecerá un nuevo nodo.

Paso 7: Predicción de clusters

En primer lugar ejecutaremos una línea que nos permite identificar a cada nodo dentro de un grupo. Ya que tenemos 4 grupos, estos se identificarán de la siguiente manera: 0, 1, 2, 3.

KMean.labels_

Al ejecutar esta línea tendremos:

Vemos como cada una de las 60 instituciones educativas (nodos), tienen un identificador de grupo dentro del modelo.

Ahor, dadas las coordenadas de un nuevo nodo, podemos predecir el grupo al cual pertenecerá:

sample_test=np.array([-3.433,-76.22])
second_test=sample_test.reshape(1, -1)
KMean.predict(second_test)

Al ejecutar este fragmento tendremos:

Es decir, el algoritmo predice que de acuerdo a las coordenada dadas, el nuevo nodo formaría parte del clúster 0.

Pudimos observar cómo varía el resultado dependiendo de la consideración de atributos netamente geoespaciales, y de atributos no espaciales, como la ponderación de cada nodo.

Integración con mapas de calor y entornos geográficos reales

Uno de los puntos negativos del modelo que acabamos de desarrollar es quizá que no nos permite visualizar gráficamente la densidad de los puntos. Si observamos las gráficas, todos los puntos parecen tener el mismo tamaño, y si bien esta no es una consideración para el funcionamiento del algoritmo; en el análisis preliminar quisiéramos tener esta herramienta. Otra consideración adicional sería la posibilidad de graficar todos nuestros puntos, y los centros de gravedad de cada (clúster) en un entorno geográfico real.

Pues bien, una de las ventajas fundamentales de Python consiste en que podemos integrar distintos desarrollos en nuestros modelos, tal es el caso del desarrollo que efectúanos en un artículo anterior (Mapas de calor y Entornos geográficos reales); de tal manera que podamos complementar nuestro modelo.

No vamos a profundizar en la librerías, ni en la definición de las variables, para eso recomendamos leer el artículo. Veamos entonces, como complementamos este modelo:

import folium
import statistics
from folium.plugins import HeatMap
mediaLong = statistics.mean(Lon)
mediaLat = statistics.mean(Lat)

# Crear un objeto de mapa base Map()
mapa = folium.Map(location=[mediaLat, mediaLong], zoom_start = 13)

# Crear una capa de mapa de calor
mapa_calor = HeatMap( list(zip(Lat, Lon, data["Peso"])),
                   min_opacity=0.2,
                   max_val=data["Peso"].max(),
                   radius=50, 
                   blur=50, 
                   max_zoom=1)

#Creamos el marcador de Centro de Gravedad
tooltip = 'Centro de gravedad'
folium.Marker([KMean.cluster_centers_[0][0], KMean.cluster_centers_[0][1]], popup="Centro", tooltip = tooltip).add_to(mapa)
folium.Marker([KMean.cluster_centers_[1][0], KMean.cluster_centers_[1][1]], popup="Centro", tooltip = tooltip).add_to(mapa)
folium.Marker([KMean.cluster_centers_[2][0], KMean.cluster_centers_[2][1]], popup="Centro", tooltip = tooltip).add_to(mapa)
folium.Marker([KMean.cluster_centers_[3][0], KMean.cluster_centers_[3][1]], popup="Centro", tooltip = tooltip).add_to(mapa)

# Adherimos la capa de mapa de calor al mapa principal
mapa_calor.add_to(mapa)
mapa

Al ejecutar este fragmento tendremos el siguiente resultado:

Ahora tenemos un modelo capaz de agrupar nuestros nodos en clusters de acuerdo a atributos geoespaciales; capaz de determinar los centros de gravedad de cada cluster de acuerdo a atributos no espaciales (en nuestro caso la población de los nodos); capaz de complementarse con una capa de visualización de mapa de calor que nos permite apreciar la densidad y todo esto puede visualizarse en un entorno geográfico real.

Consideraciones finales

Ya lo expresamos anteriormente, la base del algoritmo K-Means es la consideración y minimización de la inercia, y en espacios de muy altas dimensiones, las distancias suelen inflarse, ya que esta no es una medida normalizada.

Sin embargo, para los efectos que hemos empleado, el algoritmo suele arrojar resultados satisfactorios.

El código completo de este desarrollo lo puedes encontrar en nuestro cuaderno: Localización de varias instalaciones mediante agrupación geoespacial y Centro de Gravedad (Python).

La entrada Localización de varios almacenes mediante agrupación geoespacial se publicó primero en Ingenieria Industrial Online.

Ya en artículos anteriores hemos abordado el uso de tecnología como herramienta que permita desarrollar problemas de análisis preliminar y localización de instalaciones, con el objetivo de incrementar el nivel de aplicabilidad de estas herramientas, utilizando algunos entornos de programación, algunos sistemas de información geográfica, librerías de geocodificación; etc., que nos facilitan la adopción de soluciones basadas en entornos reales.

Algunos de los artículos que hemos desarrollado al respecto son:

En estos artículos mencionamos que los mapas de calor aplicados a la localización de instalaciones, son capas de visualización que no nos proporcionan como resultado una localización específica; sí nos proporcionan una visión de densidad basada en un factor de ponderación establecido (Peso). Sin embargo, al utilizar mapas de calor en entornos como por ejemplo Python, podemos integrar a esta herramienta, un método heurístico que nos proporcione una localización específica, como por ejemplo el Centro de Gravedad.

El objetivo de este artículo será el de utilizar mapas de calor y el algoritmo de Centro de gravedad de manera simultánea a través de Python; como herramienta de análisis preliminar y de localización de una instalación.

En el desarrollo de este ejercicio emplearemos:

Para desarrollar estas herramientas, vamos a plantear un caso típico de localización de una instalación (por ejemplo un depósito) a partir de la consideración de otras instalaciones (nodos de demanda, por ejemplo).

Caso de aplicación

La empresa Bio-Food está desarrollando un nuevo modelo de negocio en la ciudad de Cali, Colombia. Este consiste en abastecer de comida saludable a la comunidad por medio de Vending Machines (Máquinas expendedoras). En las etapas de formulación de negocio, algo quedó muy claro: El éxito de su modelo consiste en maximizar la disponibilidad de todos los SKUs en cantidades suficientes. Algunas de las referencias son productos perecederos, de manera que consideran que algunos de sus equipos requerirán visitas diarias de reposición, y otros quizá sean surtidos en más de dos ocasiones por día.

La fase inicial de su proyecto consideró la instalación de 13 equipos expendedores en 13 instituciones de educación superior de la ciudad. La logística inicial de su proyecto fue caótica (en fase piloto), algunos equipos funcionaron como sub-bodegas; algunos equipos fueron abastecidos directamente por los proveedores; y consideran la instalación de una bodega principal desde la cual serán abastecidas todas las máquinas que tienen disponibles.

La fase inicial del proyecto arrojó información alrededor del volumen de ventas de cada equipo. Por esta razón, el departamento de logística considera utilizar esta información para efectuar un análisis preliminar y establecer la localización de la bodega principal. A continuación, se relacionan los movimientos de los equipos (media de unidades vendidas por día):

Utilizar el algoritmo de Centro de Gravedad puede servir como referencia para establecer una ubicación tentativa. Sin embargo, las posibilidades de que las coordenadas solución correspondan con un espacio disponible para la ubicación de la instalación son, de verdad, muy pocas.

Por esta razón, es interesante complementar este modelo mediante una capa de visualización de mapas de calor, que consideren la densidad del volumen de ventas de los equipos. De esta manera, puede complementarse el análisis preliminar para la localización de la bodega principal.

Paso 1: Crear el entorno de trabajo en Colaboratory

Lo primero que vamos a hacer consiste en crear un entorno de trabajo en Google Colaboratory, así que vayamos allá: Abrir cuaderno nuevo.

Verán que tienen un lienzo para programar el modelo, así que en este cuaderno podemos ir generando las líneas de código que explicaremos en los pasos siguientes.

Paso 2: Importar las librerías necesarias

Respecto a las librerías, en la introducción del artículo hicimos una descripción de la funcionalidad de cada una, veamos como importarlas en nuestro entorno:

# importar las librerías necesarias
import pandas as pd
import numpy as np
import folium
import statistics
from folium.plugins import HeatMap
import geopy
from geopy.extra.rate_limiter import RateLimiter

De esta manera, tenemos todo lo necesario para empezar a desarrollar nuestro código.

Paso 3: Importar los datos desde Excel

De acuerdo a las necesidades del modelo, podemos desarrollar un código que permita la entrada manual de la información, la captura de los datos desde entornos digitales (Internet, por ejemplo), o podemos, desde luego, alimentar nuestro modelo con información contenida en documentos externos, como es el caso de un archivo de Microsoft Excel.

Esta puede considerarse como una de las ventajas de utilizar Python, su capacidad de integrarse con cualquier fuente de datos. En nuestro caso, toda la información se encuentra contenida en un documento de Excel, el cual presenta el siguiente formato:

En Colaboratory, el siguiente fragmento permitirá cargar un archivo al entorno de ejecución:

from google.colab import files

uploaded = files.upload()

for fn in uploaded.keys():
  print('User uploaded file "{name}" with length {length} bytes'.format(
      name=fn, length=len(uploaded[fn])))

Al ejecutar este fragmento de código, se abrirá una ventana emergente del explorador que permitirá cargar nuestra base de datos, en nuestro caso el archivo tienen el nombre de vending_machines.xlsx.

La siguiente línea de código permitirá almacenar los datos contenidos en el documento en un Dataframe de nuestro entorno, dentro de la variable data.

#Leer el documento de Excel y almacenar los datos en la variable data
data = pd.read_excel('vending_machines.xlsx')

Paso 4: Geocodificar las ubicaciones

Nosotros podemos partir desde la disponibilidad de las coordenadas geográficas de los puntos disponibles (Equipos expendedores). En cuyo caso, geocodificar las ubicaciones no sería necesario. Sin embargo, en nuestro ejemplo, disponemos del nombre de cada institución donde se encuentran ubicados los equipos, así como la ciudad y el país (todos los equipos se encuentran en la misma ciudad); y es necesario geocodificar estos puntos para obtener las coordenadas de latitud y longitud de cada ubicación.

Para lograrlo, utilizaremos el servicio de la librería Geopy (Llamado Nominatim), el cual puede geocodificar nuestras ubicaciones. El servicio funciona de una manera sencilla, recibe una cadena con la información de nuestra ubicación, por ejemplo: ciudad, país, nombre del lugar; y devuelve las coordenadas de latitud y longitud asociadas a cada cadena.

Las siguientes líneas en primer lugar construyen cada cadena por punto (dirección), es decir, concatenan los datos (país, ciudad y nombre del lugar), y luego son geocodificados por Geopy. Veamos:

# fusionamos los datos país, ciudad y lugar en una misma cadena de dirección
geopy.geocoders.options.default_user_agent = "my-application"
data["direccion"] = data["pais"] + ", " + data["ciudad"] + ", " + data["Institución / Lugar"]
#Envíamos los datos a geocodificación
servicio = geopy.Nominatim()
data["coordenadas"] = data["direccion"].apply(RateLimiter(servicio.geocode,min_delay_seconds=1))

Pueden apreciar que el código establece que tanto las cadenas con las direcciones concatenadas, como las respuestas en manera de coordenadas, queden dentro del mismo DataFrame donde se encuentran los datos de entrada del modelo. Podemos en cualquier momento confirmar si la geocodificación se ha realizado correctamente, para eso imprimiremos las primeras cinco filas del  DataFrame:

data.head()

Al ejecutar esta instrucción tenemos la siguiente salida:

Podemos observar cómo bajo la columna ‘direccion’ se han concatenado las columnas ‘pais’, ‘ciudad’ e ‘Institución / Lugar’, tal como lo establecimos previamente. Así mismo, podemos observar la respuesta de Geopy  bajo la columna ‘coordenadas’.

Paso 5: Calcular el Centro de Gravedad

El algoritmo de Centro de Gravedad es relativamente sencillo, mucho más cuando se cuenta con los datos debidamente organizados. Las operaciones son sencillas, y en Python, se pueden desarrollar fácilmente mediante productos de matrices.

Ahora bien, la base del algoritmo son las coordenadas. En la respuesta obtenida desde Geopy, que se encuentra contenida en la columna ‘coordenadas’ del DataFrame ‘data’, hay información adicional a las coordenadas necesarias. De hecho el servicio nos devuelve un nombre del lugar, una subregión, puede mostrarnos alguna nomenclatura y claro está, las coordenadas de latitud y longitud. Por tal razón, lo primero que debemos hacer es extraer las coordenadas de latitud y longitud, para eso utilizaremos las siguientes líneas:

# Extraer las coordenadas de latitud y longitud en dos variables separadas (listas)
longs = [coord.longitude for coord in data["coordenadas"]]
lats = [coord.latitude for coord in data["coordenadas"]]

Una vez que tengamos las coordenadas de todos los puntos en un par de variables separadas, procedemos a crear nuestro algoritmo de centro de gravedad:

centro_gravedad = {}
centro_gravedad['longs'] = np.dot(longs, data['Unidades vendidas']) / np.sum(data['Unidades vendidas'])
centro_gravedad['lats'] = np.dot(lats, data['Unidades vendidas']) / np.sum(data['Unidades vendidas'])

De esta manera, dentro del arreglo ‘centro_gravedad’ deberán quedar las coordenadas solución. Recordemos que este algoritmo utiliza puntos ponderados, en este caso el peso que determina la ponderación está dado por el volumen de ventas de cada equipo (‘Unidades vendidas’).

Podemos ver el resultado, imprimiendo la variable ‘centro_gravedad’:

print(centro_gravedad)

Estas son las coordenadas solución del método de Centro de Gravedad. Sin embargo, recordemos que debemos complementar el desarrollo del modelo mediante un mapa de calor.

Paso 6: Graficar la capa del mapa de calor y el marcador de Centro de Gravedad

En este caso utilizaremos la librería Folium para ambos fines: la capa del mapa de calor, y el marcador de Centro de Gravedad.

Lo primero que haremos será calcular la media de las latitudes y las longitudes para centrar el mapa que obtendremos.

Lo segundo que haremos será crear nuestro mapa, el cual configuraremos con las medidas centrales y un zoom inicial que podemos modificar de acuerdo a nuestras necesidades.

Lo tercero que haremos será crear nuestra capa de mapa de calor, utilizaremos como peso las ‘Unidades vendidas’ para ponderar cada punto del mapa (Vending Machines). Configuramos algunos parámetros a nuestro criterio como la opacidad, la intensidad, el radio de cada punto.

Por último crearemos el marcador de Centro de Gravedad, para ello utilizaremos las coordenadas solución que hallamos en el paso anterior.

# Calcular la media de las latitudes y las longitudes para centrar el mapa
mediaLong = statistics.mean(longs)
mediaLat = statistics.mean(lats)

# Crear un objeto de mapa base Map()
mapa = folium.Map(location=[mediaLat, mediaLong], zoom_start = 12)

# Crear una capa de mapa de calor
mapa_calor = HeatMap( list(zip(lats, longs, data["Unidades vendidas"])),
                   min_opacity=0.2,
                   max_val=data["Unidades vendidas"].max(),
                   radius=50, 
                   blur=50, 
                   max_zoom=1)

#Creamos el marcador de Centro de Gravedad
tooltip = 'Centro de gravedad'
folium.Marker([centro_gravedad['lats'], centro_gravedad['longs']], popup="Centro", tooltip = tooltip).add_to(mapa)

# Adherimos la capa de mapa de calor al mapa principal
mapa_calor.add_to(mapa)
mapa

Al ejecutar estas líneas tendremos el siguiente resultado:

Podemos utilizar el zoom para explorar diversas visualizaciones de densidad:

El código completo de este desarrollo lo puedes encontrar en nuestro cuaderno: Mapas de Calor y Centro de Gravedad.

En este caso, y a diferencia del artículo mapas de calor utilizando Google Maps, empleamos una capa de visualización de densidad de cada punto, y simultáneamente identificamos unas coordenadas solución de una localización de acuerdo al modelo de Centro de Gravedad (Centro de masa). De esta forma, construimos una herramienta un poco más robusta que permite soportar los procesos de análisis preliminar de localización de instalaciones, ambientada en un entorno geográfico real.

Así mismo, en el desarrollo de la herramienta empleamos algunas instrucciones que nos permiten automatizar procesos de georeferenciación, y de uso de datos a partir de fuentes diversas.

El alcance de este modelo se encuentra determinado por la localización de una sola instalación (depósito, almacén, etc.), y en los casos en los que se requiera determinar múltiples localizaciones, el modelo no aplica.

La entrada Mapas de calor y Algoritmo de Centro de Gravedad utilizando Python se publicó primero en Ingenieria Industrial Online.

El objetivo de este artículo es precisamente ese, apoyarnos en las nuevas herramientas que nos proporciona la tecnología, para abordar un problema de localización de una instalación aplicando el algoritmo de centro de gravedad de una manera práctica. Para ello utilizaremos R, de hecho, utilizaremos las librerías de R en un cuaderno virtual de Python.

El resultado de nuestro código nos arrojará la localización, de acuerdo al sistema de coordenadas que empleemos, además de que graficará la misma, y los puntos ponderados del modelo (peso de acuerdo a su demanda, producción, capacidad, etc.).

Requerimientos para ejecutar el modelo

En este caso sugerimos utilizar un entorno virtual de programación. Recomendamos el uso de Colaboratory de Google, un entorno que cuenta con todas las herramientas necesarias para nuestros desarrollos en Python. No tendremos que instalar nada en nuestro equipo, y aprovecharemos la potencia de las máquinas de Google, y su capacidad para ejecutar R.

Programación del modelo de Centro de Gravedad en R

Vamos a asumir que utilizarán el entorno virtual de Colaboratory, así que vayamos allá: Abrir cuaderno nuevo.

Ya que este entorno está desarrollado para escribir y ejecutar códigos en Python, lo primero que debemos hacer es ejecutar el siguiente comando en nuestro cuaderno, para así poder utilizar R en nuestro entorno:

import rpy2
rpy2.__version__
import rpy2.robjects.conversion
%load_ext rpy2.ipython

Después de eso, cada vez que desee usar R, agregue %%R al comienzo de cada celda. Veamos.

Lo primero que crearemos será a función del cálculo del Centro de Gravedad, la matemática detrás de esto no es nada especial, se trata de un producto cruzado de matrices para cada coordenada, para lo que utilizaremos crossprod de R.

%%R 
centro_gravedad <- function(x,y,w){
  c(crossprod(x,w)/sum(w),crossprod(y,w)/sum(w))
}

x = Coordenada en x (Que puede ser una coordenada cartesiana, latitud, etc.)

y = Coordenada en y (Que puede ser una coordenada cartesiana, longitud, etc.)

w = Representa el peso de cada punto dado (Que puede ser la demanda, la capacidad, la producción)

En nuestro caso, x y y serán coordenadas cartesianas, y w será la capacidad de suministro de gasolina de cada distribuidor. La función anterior calculará el centro de gravedad de acuerdo a los datos de entrada del modelo.

Ahora crearemos el marco de datos (dataframe al cual llamaremos estaciones_df) en el que se consignarán nuestros datos de entrada:

%%R
estaciones_df <- as.data.frame(matrix(nrow=5,ncol=3))
encabezados(estaciones_df) <- c("x","y","galones")

estaciones_df$x <- c(58.7, 26.2, 32.9, 42.5, 36.4)
estaciones_df$y <- c(4.4, 5.2, 3.8, 4.1, 6.2)
estaciones_df$galones <- c(3800, 2700, 310, 420, 250)

El código anterior crea un marco de datos (matrix) de 5 filas y 3 columnas. Las filas representan el número de estaciones de gasolina que nos da el ejemplo, y las columnas servirán para consignar 3 valores: coordenada en x, coordenada en y y el suministro de gasolina en galones de cada estación.

Consignaremos los datos de entrada del ejemplo cuidando el orden estricto en el que registramos la información. Al finalizar tendremos toda la información consignada en nuestro marco de datos; para comprobarlo ejecutaremos el siguiente código:

%%R
(estaciones_df)

Al ejecutarlo, tendremos la siguiente salida:

Podemos corroborar que la información se ha consignado adecuadamente.

El siguiente paso consiste en calcular el centro de gravedad del modelo, para eso asignaremos los datos de entrada a la función inicial de centro de gravedad:

%%R
centro_gravedad(estaciones_df$x,estaciones_df$y,estaciones_df$galones)

Recordemos que de acuerdo a la función inicial, esta necesita 3 argumentos: x, y, w (coordenada en x, coordenada en y, peso). Esta información se encuentra en el marco de datos de entrada (estaciones_df).

Al ejecutarlo, tendremos la siguiente salida:

Esto quiere decir que en el sistema de coordenadas utilizado para establecer las ubicaciones propuestas en el ejercicio, la instalación óptima se ubicaría en las coordenadas X = 44,2 – Y = 4,7. podemos confirmar que son las mismas coordenadas obtenidas mediante el modelo matemático original de Centro de Gravedad.

Tanto el resultado obtenido, como las ubicaciones de entrada (estaciones) pueden graficarse para una mayor comprensión del modelo. Utilizaremos un gráfico utilizando la librería ggplot2 que nos muestre las instalaciones con un marcador de acuerdo a su ponderación. Veamos:

%%R
library(ggplot2)
grafico_df <- rbind(estaciones_df,c(centro_gravedad(estaciones_df$x,estaciones_df$y,estaciones_df$galones),2500))
grafico_df$tipo <- c(rep(x="distribuidores",times=5),"instalacion")
ggplot(data=grafico_df) + geom_point(mapping=aes(x=x,y=y,size=galones,color=tipo))

Al ejecutar tendremos el siguiente resultado:

El marcador azul representa la ubicación sugerida por el modelo, de acuerdo a la ubicación del suministro de acuerdo a las estaciones. Podemos ver como el tamaño de las estaciones varía de acuerdo a su capacidad de suministro. Esta forma de desarrollar el modelo de Centro de Gravedad puede complementarse con diversas fuentes de datos, mapas de calor, tipos de coordenadas, etc.

Puedes ver el cuaderno de este módulo en nuestro Colaboratory: Problema de localización de instalaciones mediante Centro de Gravedad.

Consideraciones finales

El alcance de este modelo se encuentra determinado por la localización de una sola instalación (depósito, almacén, etc.), y en los casos en los que se requiera determinar múltiples localizaciones, el modelo no aplica.

La entrada Método del Centro de gravedad utilizando R se publicó primero en Ingenieria Industrial Online.

Es conocido, que los problemas de asignación puros son una variación del problema original del transporte, en cuyos casos las variables de decisión solo pueden tomar valores binarios. ¿Esto qué significa? Pues bien, como algoritmo de red, un problema básico de transporte es un modelo de asignación genérico; modelo en el cual se pretende establecer la asignación entre fuentes y destinos; es decir, cuántas unidades se transportarán desde el origen i hacia el destino j. Se entiende además, que en el caso del transporte, estas variables de asignación no son necesariamente binarias.

El objetivo de este artículo consiste en utilizar las librerías del software Google OR-Tools (Python), para abordar un problema de transporte básico, de acuerdo a un modelo de asignación.

El problema

Con el propósito de evaluar los resultados obtenidos a través del tratamiento de un problema técnicamente formulado y abordado, utilizaremos un caso descrito en el libro Investigación de Operaciones (9na edición), de Hamdy A. Taha (University of Arkansas, Fayetteville), (Ejemplo 5.1-1):

MG Auto cuenta con tres plantas en Los Ángeles, Detroit y Nueva Orleáns, y dos importantes centros de distribución en Denver y Miami. Las capacidades trimestrales de las tres plantas son 1000, 1500 y 1200 automóviles, y las demandas de los dos centros de distribución durante el mismo periodo son de 2300 y 1400 automóviles. La distancia en millas entre las plantas y los centros de distribución aparece en la siguiente tabla: Hamdy A. Taha

Relación de distancias entre plantas y cedis

Distancia dada en millas

El caso también plantea que la compañía de transporte cobra 8 centavos por milla por automóvil. Así entonces, el objetivo del modelo no será minimizar la distancia total, sino minimizar el costo total de transporte. Con base en la distancia dada en millas y el costo de transporte unitario, construimos nuestra tabla de costos (redondeada al dólar más cercano):

Relación de costos de distribución entre plantas y cedis

Costo dado en dólares automóvil

La representación gráfica de la red sería la siguiente:

Resolviendo un problema de transporte mediante Or Tools (Asignación)

De acuerdo a lo mencionado en el artículo de introducción a Google OR-Tools, esta herramienta soporta múltiples lenguajes de programación, así entonces, haremos uso del lenguaje de programación Python.

Utilizaremos un solucionador para programación lineal mixta: SCIP.

Importar librerías

El primer paso consiste en importar la librería de Google Or Tools, esto nos permitirá utilizar todas sus funciones.

from ortools.linear_solver import pywraplp

Declarar el solucionador

Tal como lo mencionamos, vamos a utilizar un solucionador de programación lineal mixta. Esto nos permitirá utilizar tanto variables enteras como variables continuas. Debemos declarar el solucionador SCIP.

solver = pywraplp.Solver.CreateSolver('SCIP')

Crear la data del modelo

La data base del modelo corresponde a la matriz de costos. Debemos de considerar que el orden en el que se ingresa la información corresponda a la relación precisa entre las variables; veamos:

costos = [
    [ 80, 215],
    [100, 108],
    [102,  68],
]

num_plantas = len(costos)
num_cedis = len(costos[0])

Así mismo, utilizaremos el método len para calcular el número de plantas y el número de cedis. En el caso de las plantas, contará el número de filas de la matriz; en el caso de los cedis, contará en número de columnas (para saber que contará las columnas de la matriz se utiliza costos[0]).

Crear las variables del modelo

Este es un problema básico, y como tal las únicas variables necesarias serán las asignaciones. Es decir, las variables x[i, j], donde i representa el origen y j representa el destino. Este proceso es relativamente sencillo y puede generarse cada variable de manera manual, sin embargo, automatizaremos la creación de las variables por medio de ciclos, con el propósito de preparar nuestro código para problemas más robustos:

x = {}
for i in range(num_plantas):
    for j in range(num_cedis):
        x[i, j] = solver.IntVar(0, solver.infinity(), '')

De esta manera se crean las variables de asignación. Es decir, tendremos tantos i como número de plantas (orígenes), asociados a tantos j como número de cedis (destinos). La naturaleza de las variables es entera (solver.IntVar), ya que hace referencia a la distribución de automóviles. Desde la creación de las variables podemos definir su rango, en este caso diremos que será desde 0 hasta infinito (solver.infinity).

Así entonces, se entiende que, por ejemplo, la variable x[0,0] hace referencia al número de automóviles que se enviarán desde el origen 0 (Los Ángeles) hacia el destino 0 (Denver). El orden de la asignación se basa en la matriz de costos.

El código anterior crea todas las variables de asignación necesarias.

Crear las restricciones

#Restricciones de disponibilidad (oferta en plantas)
solver.Add(solver.Sum([x[0, j] for j in range(num_cedis)]) <= 1000)
solver.Add(solver.Sum([x[1, j] for j in range(num_cedis)]) <= 1500)
solver.Add(solver.Sum([x[2, j] for j in range(num_cedis)]) <= 1200)

#Restricciones de demanda (cedis)
solver.Add(solver.Sum([x[i, 0] for i in range(num_plantas)]) >= 2300)
solver.Add(solver.Sum([x[i, 1] for i in range(num_plantas)]) >= 1400) 

El método Add de solver, nos servirá para agregar las restricciones al modelo. Las restricciones de oferta y demanda necesarias se adicionan tal cual el código anterior. Explicaremos la primera de ellas:

solver.Add(solver.Sum([x[0, j] for j in range(num_cedis)]) <= 80)

La anterior restricción indica que, la sumatoria de todas las variables x[0, j], para los j del conjunto cedis deberá ser menor o igual a 1000. Esto significa que la cantidad enviada desde el nodo (planta) 0 hacia los destinos j (Denver y Miami) no puede ser mayor que su disponibilidad de automóviles.

Crear la función objetivo

Tal como lo planteamos desde la formulación del problema, el criterio de optimización des este modelo corresponde a minimizar el costo total de distribución. El siguiente fragmento calcula el producto entre cada variable x[i, j] y su respectivo costo c[i, j] (obtenida desde la matriz de costos). La sumatoria de productos corresponde a la ecuación objetivo.

for i in range(num_plantas):
    for j in range(num_cedis):
        objective_terms.append(costos[i][j] * x[i, j])
solver.Minimize(solver.Sum(objective_terms))

Luego se declara el criterio de optimización: Minimize (para minimizar) y Maximize (para maximizar). En este caso minimizará la sumatoria de los productos.

Invocar al solucionador

La siguiente línea indica que el modelo debe solucionarse.

status = solver.Solve()

Configurar las salidas del modelo

if status == pywraplp.Solver.OPTIMAL or status == pywraplp.Solver.FEASIBLE:
    print('Costo total = ', solver.Objective().Value(), '\n')

    for i in range(num_plantas):
        for j in range(num_cedis):
            print('|Planta {} -> Cedi {} - Cantidad: {}|'.format(
            i,
            j,
            x[i, j].solution_value()))

En el caso en el que el modelo encuentre una solución óptima, hemos configurado las salidas de tal manera que nos muestre la relación solución entre fuentes > destinos y cantidades. Al ejecutar el modelo obtendremos la siguiente solución:

Podemos también detallar mucho mejor las salidas del modelo, de acuerdo al nombre de las plantas y los cedis. Para ello, en la data de entrada creamos las listas correspondientes, veamos:

costos = [
    [ 80, 215],
    [100, 108],
    [102,  68],
]

num_plantas = len(costos)
num_cedis = len(costos[0])

plantas = ['Los Ángeles', 'Detroit', 'New Orleans']
cedis = ['Denver', 'Miami']

La información de las listas debe guardar correspondencia con el orden de la matriz de costos.

Ahora, configuramos nuevamente las salidas del modelo:

if status == pywraplp.Solver.OPTIMAL or status == pywraplp.Solver.FEASIBLE:
    print('Costo total = ', solver.Objective().Value(), '\n')

    for i in range(num_plantas):
        for j in range(num_cedis):
            print('|{:^20} -> {:^20} | Cantidad: {:^20}|'.format(
            plantas[i],
            cedis[j],
            x[i, j].solution_value()))

En este caso hemos remplazado el índice solo de plantas y cedis, por el índice dentro del listado de plantas y cedis. Así entonces, tendremos la siguiente salida del modelo:

Pueden cotejar los resultados obtenidos los cuales corresponden a los mismos resultados presentados por Taha, quien utiliza TORA como solucionador.

¿Cómo ejecutar el modelo?

Alternativa 1, ejecución en nuestro equipo:

Lo primero que debemos considerar, en el caso de que queramos ejecutar este código en nuestro equipo, es que es preciso contar con la instalación de Python en nuestro equipo de cómputo y por supuesto, el software OR-Tools. Una guía detallada de la instalación de estos requerimientos la podrás encontrar en el siguiente enlace:

Instalación de OR-Tools para Python

Ahora, lo recomendable es trabajar con algún editor de código práctico (IDE), por ejemplo: Sublime Text, o Spyder (Una herramienta más completa y por ende más robusta y pesada).

Alternativa 2, ejecución en un entorno virtual (Recomendado):

Podemos utilizar del mismo modo, un entorno virtual. En este caso recomendamos el uso de Colaboratory de Google, un entorno que cuenta con todas las herramientas necesarias para nuestros desarrollos. No tendremos que instalar nada en nuestro equipo, y aprovecharemos la potencia de las máquinas de Google.

El código completo de nuestro desarrollo lo presentamos a continuación.

# Importar la librería de Google OR-Tools
from ortools.linear_solver import pywraplp

# Declarar el solucionador que abordará el modelo
solver = pywraplp.Solver.CreateSolver('SCIP')

# Data del modelo
costos = [
    [ 80, 215],
    [100, 108],
    [102,  68],
]

plantas = ['Los Ángeles', 'Detroit', 'New Orleans']
cedis = ['Denver', 'Miami']

num_plantas = len(costos)
num_cedis = len(costos[0])

# Variables del modelo
x = {}
for i in range(num_plantas):
    for j in range(num_cedis):
        x[i, j] = solver.IntVar(0, solver.infinity(), '')
        
#Restricciones de disponibilidad (oferta en plantas) 
solver.Add(solver.Sum([x[0, j] for j in range(num_cedis)]) <= 1000) 
solver.Add(solver.Sum([x[1, j] for j in range(num_cedis)]) <= 1500) 
solver.Add(solver.Sum([x[2, j] for j in range(num_cedis)]) <= 1200) 

#Restricciones de demanda (cedis) 
solver.Add(solver.Sum([x[i, 0] for i in range(num_plantas)]) >= 2300) 
solver.Add(solver.Sum([x[i, 1] for i in range(num_plantas)]) >= 1400)      



# Función objetivo con criterio de optimización: minimizar
objective_terms = []
for i in range(num_plantas):
    for j in range(num_cedis):
        objective_terms.append(costos[i][j] * x[i, j])

solver.Minimize(solver.Sum(objective_terms))

# Invoca el solucionador
status = solver.Solve()

# Configura los parámetros de impresión, las salidas del modelo
if status == pywraplp.Solver.OPTIMAL or status == pywraplp.Solver.FEASIBLE:
    print('Costo total = ', solver.Objective().Value(), '\n')

    for i in range(num_plantas):
        for j in range(num_cedis):
            print('|{:^20} -> {:^20} | Cantidad: {:^20}|'.format(
            plantas[i],
            cedis[j],
            x[i, j].solution_value()))

También es posible integrar nuestro desarrollo con data proveniente de fuentes externas, como por ejemplo Excel.

En próximos artículos, resolveremos el problema de transporte básico mediante un algoritmo de flujo mínimo.

La entrada Solución de un modelo de transporte mediante un algoritmo de asignación se publicó primero en Ingenieria Industrial Online.

Su uso se aplica con relativo éxito en muchos ámbitos, soportando metodologías de priorización, por ejemplo. El diagrama de Pareto hace parte de lo que se denominan técnicas gráficas de calidad, como lo son las siete herramientas básicas, utilizadas para la solución de problemas referentes a la calidad, mencionadas por primera vez por Kaoru Ishikawa.

El objetivo de este artículo consiste en el desarrollo de un par de metodologías de elaboración de diagramas de Pareto, haciendo uso de dos herramientas: la tradicional hoja de cálculo de Excel, y el popularizado lenguaje de programación Python.

Diagrama de Pareto en Excel (2016)

Supongamos que un proceso que produce refrigeradores desea establecer controles sobre los defectos que aparecen en las unidades que salen como producto terminado en la línea de producción. Para ello se hace necesario determinar cuáles son los defectos más frecuentes. En primer lugar se clasificaron todos los defectos posibles:

Después de inspeccionar 88 refrigeradores defectuosos, se obtuvo la siguiente tabla de frecuencias:

Ordenamos los datos de mayor  a menor y anexamos una columna de frecuencia relativa (porcentual) y otra de frecuencia relativa acumulada (porcentual). Para obtener las frecuencias relativas utilizamos la siguientes fórmulas:

Veamos por ejemplo la frecuencia relativa del defecto «motor no se detiene«:

Podemos calcular la frecuencia relativa porcentual de la siguiente manera:

Veamos cómo hacerlo en Excel:

Recuerde que previamente debe ordenar las frecuencias de mayor a menor. Utilizando esta formulación, obtenemos el siguiente resultado:

Aquí podemos observar como la causa 1: motor no se detiene se ha presentado con una frecuencia de 36 defectos (de un total de 88 defectos totales), lo que representa un 40,91% del total de defectos. También podemos, con base en nuestra data de estudio, que las causas 1, 2 y 3, representan más del 80% de los defectos totales (81,82% exactamente). Si consideramos que estas son 3 causas de 12 causas totales, esto se aproxima a la regla empírica de Pareto (3/12 = 0,25). En este caso, el 81,82% de los defectos se debe al 25% de las causas.

Veamos ahora cómo graficar el Diagrama de Pareto tradicional:

Seleccionamos los datos de las columnas ‘Tipo de defecto’, ‘Frecuencia’ y ‘Frecuencia relativa acumulada’. A continuación damos clic en el Menú “Insertar”; seleccionamos «Gráficos recomendados”; luego en “Pareto”.

A diferencia de otras versiones, desde Microsoft Excel 2016 podemos acceder a este tipo de representación gráfica con suma facilidad:

Diagrama de Pareto en Python

Quienes prefieran utilizar algún lenguaje de programación, ya sea porque el diagrama que requieren acompañará un desarrollo o un modelo más robusto, integrará datos desde fuentes externas, o simplemente así lo prefieren; pueden utilizar Python para graficar su Pareto son suma facilidad. Explicaremos el código paso a paso, sin embargo, al finalizar, dejaremos el código completo para su disposición.

Importar las librerías

En este caso, requerimos del uso de dos librerías

import pandas as pd
import matplotlib.pyplot as plt

Crear la data de entrada y ordenarla

df = pd.DataFrame({'frecuencia': [9, 5, 1, 1, 1, 36, 27, 2, 0, 0, 2, 4]})
df.index = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12']
df = df.sort_values(by='frecuencia',ascending=False)

En la variable df quedará contenida la data de entrada en un Dataframe. Inicialmente agregaremos las frecuencias de acuerdo a nuestro ejemplo.

Posteriormente, por medio de df.index nombraremos las causas de acuerdo al orden de las frecuencias ya asignadas. Preferimos en este caso numerarlas en lugar de colocar el nombre de cada defecto. Por ejemplo:

Burlete defectuoso = Causa 1 (Frecuencia 9)

Pintura defectuosa = Causa 2 (Frecuencia 5)

La siguiente línea de código utiliza el método .sort_values para ordenar las frecuencias contenidas en df de forma descendente. El resultado parcial de df será:

Calcular la frecuencia relativa porcentual acumulada

frecuencia_relativa = df["frecuencia"].cumsum()
total_defectos = df["frecuencia"].sum()
df["relativa_acum_porcentual"] = frecuencia_relativa/total_defectos*100

La frecuencia relativa se calcula con la función .cumsum. Por eso seleccionamos dentro del DataFrame df la columna frecuencia. El número total de defectos se calcula con la función .sum sobre la columna frecuencia.

Para calcular la frecuencia relativa porcentual, dividimos la columna frecuencia relativa entre el total de defectos y se multiplica por 100. Tal como se puede observar en la última línea del código. El resultado parcial de df será:

Graficar el diagrama de Pareto

El último paso corresponde a graficar:

fig, ax = plt.subplots()
ax.bar(df.index, df["frecuencia"], color="C0")
ax2 = ax.twinx()
ax2.plot(df.index, df["cumpercentage"], color="C1", marker="o", ms=5)


plt.show() 

El resultado será:

¿Cómo ejecutar el modelo?

Alternativa 1, ejecución en nuestro equipo:

Lo primero que debemos considerar, en el caso de que queramos ejecutar este código en nuestro equipo, es que es preciso contar con la instalación de Python.

Ahora, lo recomendable es trabajar con algún editor de código práctico (IDE), por ejemplo: Sublime Text, o Spyder (Una herramienta más completa y por ende más robusta y pesada).

Alternativa 2, ejecución en un entorno virtual (Recomendado):

Podemos utilizar del mismo modo, un entorno virtual. En este caso recomendamos el uso de Colaboratory de Google, un entorno que cuenta con todas las herramientas necesarias para nuestros desarrollos. No tendremos que instalar nada en nuestro equipo, y aprovecharemos la potencia de las máquinas de Google.

Puedes ver y ejecutar el cuaderno de este módulo en nuestro Colaboratory: Diagrama de Pareto en Python.

Código completo:

import pandas as pd
import matplotlib.pyplot as plt

df = pd.DataFrame({'frecuencia': [9, 5, 1, 1, 1, 36, 27, 2, 0, 0, 2, 4]})
df.index = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12']
df = df.sort_values(by='frecuencia',ascending=False)
frecuencia_relativa = df["frecuencia"].cumsum()
total_defectos = df["frecuencia"].sum()
df["cumpercentage"] = frecuencia_relativa/total_defectos*100


fig, ax = plt.subplots()
ax.bar(df.index, df["frecuencia"], color="C0")
ax2 = ax.twinx()
ax2.plot(df.index, df["cumpercentage"], color="C1", marker="o", ms=5)


plt.show()

La entrada ¿Cómo hacer un diagrama de Pareto utilizando Excel o Python? se publicó primero en Ingenieria Industrial Online.

Quienes nos adentramos desde hace varios años en el mundo de la estimación de la demanda, hemos considerado a la regresión lineal, o al método de los mínimos cuadrados, como un modelo de pronóstico, no mucho más que eso.

Sabemos que nos permite hallar el valor esperado de una variable aleatoria a cuando b toma un valor específico. Entendemos que este método implica un supuesto de linealidad cuando la demanda presenta un comportamiento creciente o decreciente.

Es común que hagamos uso de una hoja de cálculo sobre la cual aplicamos las fórmulas de regresión, tal como lo detallamos en este artículo de introducción: regresión lineal.

Sin embargo, con los avances computacionales, con el incremento de la capacidad de procesamiento de información, con el crecimiento de las herramientas utilizadas en la ciencia de datos; con la consideración de términos como inteligencia artificial, machine learning, y muchos conceptos relacionados; podemos definir a la regresión lineal en este contexto: La regresión lineal es una técnica paramétrica de Machine Learning. Es un algoritmo supervisado.

En esta oportunidad, y teniendo en cuenta lo que venimos mencionando; utilizaremos Python, y una librería para aprendizaje automático: scikit-learn, para abordar modelos de regresión lineal. Las ventajas de Python como lenguaje que nos permita integrar diversas aplicaciones, fuentes de información, y posibilidades de modelamiento de datos a gran escala, son muchas. Por esta razón dejaremos esta herramienta a disposición.

Ejemplo de aplicación de Regresión lineal mediante Python

Importar librerías

Para llevar a cabo este ejercicio necesitaremos una serie de librerías, vamos a describir cada una de ellas:

import numpy as np
import matplotlib.pyplot as plt
from sklearn import linear_model
from sklearn.metrics import mean_squared_error, r2_score

Desde la librería sklearn importaremos las clases liner_model y mean_squared_error para obtener la regresión lineal por mínimos cuadrados y para evaluar la calidad de a regresión.

Crear la data de entrada

De acuerdo a nuestro ejemplo, los periodos los almacenaremos en una lista contenida en la variable x. Así mismo, los datos de la demanda los almacenaremos en una lista contenida en la variable y.

Crearemos una lista (z) con los períodos que queremos pronosticar, en este caso, las ventas para el periodo 7.

x = [1,2,3,4,5,6]
y = [7000,  9000, 5000, 11000, 10000, 13000]
z = [7]

#Convertimos las listas de entrada en matrices
x = np.array(x)
y = np.array(y)
z = np.array(z)

#Graficamos los datos de entrada
plt.scatter(x,y,label='data', color='blue')
plt.title('Distribución entre meses y demanda');

Las listas con los datos de entrada los convertiremos en matrices para procesar posteriormente la información. El modelo de aprendizaje automático trabaja a partir de matrices.

Por último, graficaremos la data de entrada. El resultado parcial de nuestro programa será:

Entrenar el modelo de regresión lineal

Crearemos una instancia de la clase LinearRegression con el nombre de regresion_lineal. A continuación, utilizaremos el método fit el cual ajusta el modelo lineal de acuerdo a los datos de entrada (x, y).

regresion_lineal = linear_model.LinearRegression()
regresion_lineal.fit(x.reshape(-1,1), y) 
# Imprimimos los parámetros que ha estimado la regresión lineal
print('\nParámetros del modelo de regresión')
print('b (Pendiente) = ' + str(regresion_lineal.coef_) + ', a (Punto de corte) = ' + str(regresion_lineal.intercept_))

Lo siguiente que haremos – y ya que el modelo de regresión se ha ajustado a los datos de entrada – será obtener los parámetros de regresión:

Hemos añadido algo de formato a los parámetros que mostrará el desarrollo. Veamos:

En este punto ya hemos obtenido a través del modelo entrenado, los parámetros de regresión del conjunto de datos.

Prediciendo datos a partir del modelo entrenado

Toda vez que el modelo ha obtenido los parámetros de regresión, podemos predecir datos utilizando el método predict.

En este caso, queremos pronosticar el valor de la demanda (y) para el periodo 7 (z).

pronostico = regresion_lineal.predict(z.reshape(-1,1))

print('\nPronósticos')
for i in range(len(z)):
print('Pronóstico para el periodo {0} = {1} '.format(z[i], pronostico[i]))

La matriz de las predicciones se almacenará en la variable pronostico. El método predict hará la tarea. Recordemos que los periodos a partir de los cuales queremos conocer la demanda se encuentran en la matriz z. Por ende, queremos predecir con base en los valores de z. Así:

pronostico = regresion_lineal.predict(z.reshape(-1,1))

Podríamos simplemente imprimir la variable pronostico, en cuyo caso obtendremos nuestras predicciones en forma de matriz. Sin embargo, hemos decidido utilizar un bucle que nos imprima línea por línea (útil en los casos en los cuales queramos ronostica más de un período). Veamos el resultado parcial de nuestro código:

Podemos observar que la estimación de la regresión lineal del modelo que acabamos de entrenar para x = 7 es y = 13066,66. Puede contrastar este resultado con el obtenido mediante hojas de cálculo: regresión lineal.

Evaluando la calidad de la regresión

Para evaluar la calidad del modelo de regresión desarrollado utilizaremos el error cuadrático medio y el coeficiente de determinación R². Ambos datos podemos obtenerlos de una manera muy sencilla mediante la librería empleada. Veamos:

pronostico_entrenamiento = regresion_lineal.predict(x.reshape(-1,1))
mse = mean_squared_error(y_true = y, y_pred = pronostico_entrenamiento)
rmse = np.sqrt(mse)
print('\nEvaluación de calidad de la regresión')
print('Error Cuadrático Medio (MSE) = ' + str(mse))
print('Raíz del Error Cuadrático Medio (RMSE) = ' + str(rmse))

r2 = regresion_lineal.score(x.reshape(-1,1), y)
print('Coeficiente de Determinación R2 = ' + str(r2))

Para tratar de simplificar lo anterior, podemos decir que en la práctica lo necesario es calcular el pronóstico para los valores en x conocidos como valores de entrada; dicho en otras palabras, el pronóstico para los valores en x  utilizados para entrenar el modelo. De esa manera el error cuadrático medio (método mean_squared_error) comparará el valor de los datos en y «reales» versus los valores en y «pronosticados» (Para los x conocidos – entrenamiento -).

Para hallar la raíz del error cuadrático básicamente usamos la función de Python sqrt que calcula la raíz cuadrada del argumento dado.

Para obtener el coeficiente R² utilizaremos el método score.

Imprimiremos los valores y obtendremos:

El coeficiente R² igual a 0,532 indica la existencia de una correlación pero nada fuerte.

Graficar la línea de la tendencia del modelo

Vamos a graficar la línea de la tendencia, para eso necesitamos los valores de entrada para x y la demanda pronosticada (dependiente). Utilizaremos plot de manera que la gráfica resultante sea una línea y dentro de los argumentos le daremos color rojo.

plt.plot(x,pronostico_entrenamiento,label='data', color='red')
plt.xlabel('Meses')
plt.ylabel('Demanda')

Además nombraremos los ejes del gráfico. Veamos:

Hasta aquí hemos logrado entrenar un modelo de regresión lineal; logramos obtener la predicción con base en el modelo entrenado. Logramos graficar los datos de entrada y la línea de tendencia. Del mismo modo logramos evaluar la calidad de la regresión mediante un par de indicadores.

Veamos ahora una pequeña variación: queremos obtener predicciones para diversos periodos. Lo único que necesitaremos es modificar la lista de entrada z. En esta lista contenemos los periodos que queremos pronosticar. Veamos lo que pasa cuando z = [7, 8, 9, 10].

Aquí apreciamos la utilidad del bucle que implementamos para imprimir los pronósticos línea por línea.

A continuación, dejamos a disposición el código completo del modelo de regresión:

rojo.

import numpy as np
import matplotlib.pyplot as plt 
from sklearn import linear_model
from sklearn.metrics import mean_squared_error, r2_score

#Inputs
x = np.array([1,2,3,4,5,6]) #periodo de entrenamiento
y = np.array([7000,  9000, 5000, 11000, 10000, 13000])
z = np.array([7, 8, 9, 10, 11, 12]) #Periodos que deseo pronosticar

plt.scatter(x,y,label='data', color='blue')
plt.title('Distribución entre meses y demanda');

regresion_lineal = linear_model.LinearRegression()
regresion_lineal.fit(x.reshape(-1,1), y) 
print('\nParámetros del modelo de regresión')
print('b (Pendiente) = ' + str(regresion_lineal.coef_) + ', a (Punto de corte) = ' + str(regresion_lineal.intercept_))

# vamos a predecir el periodo 7 (z = [7]
pronostico = regresion_lineal.predict(z.reshape(-1,1))

print('\nPronósticos')
for i in range(len(z)):
    print('Pronóstico para el periodo {0} = {1} '.format(z[i], pronostico[i]))

pronostico_entrenamiento = regresion_lineal.predict(x.reshape(-1,1))
mse = mean_squared_error(y_true = y, y_pred = pronostico_entrenamiento)
rmse = np.sqrt(mse)
print('\nEvaluación de calidad de la regresión')
print('Error Cuadrático Medio (MSE) = ' + str(mse))
print('Raíz del Error Cuadrático Medio (RMSE) = ' + str(rmse))

r2 = regresion_lineal.score(x.reshape(-1,1), y)
print('Coeficiente de Determinación R2 = ' + str(r2))

plt.plot(x,pronostico_entrenamiento,label='data', color='red')
plt.xlabel('Meses')
plt.ylabel('Demanda')

La entrada Regresión lineal en Python se publicó primero en Ingenieria Industrial Online.

Quienes se adentren en los conceptos de la investigación de operaciones, propiamente en los conceptos de la programación lineal, deben considerar que existe algo más allá de la solución óptima. En investigación de operaciones, la solución de un modelo matemático establece una base para la toma de decisiones; sin embargo, puede considerarse como esencial el análisis de los resultados obtenidos.

Los resultados de un modelo de programación lineal pueden ofrecer mucha información adicional, inputs del análisis de resultados. Existen a grandes rasgos, dos tipos de análisis complementarios en PL:

En este artículo abordaremos el análisis de sensibilidad.

El análisis de sensibilidad en programación lineal corresponde al examen detallado de los límites dentro de los cuales los parámetros del modelo (recursos, utilidad o costo), pueden cambiar sin que esto afecte a la solución óptima y a la capacidad de calcular el impacto que tienen dichos cambios sobre la misma. Es decir, a partir de los resultados obtenidos de un modelo, podemos establecer una solución óptima y tenemos un rango en el cual podemos medir el impacto de los cambios en la disponibilidad de los recursos y los cambios en los coeficientes de la función objetivo. El análisis de dichas variaciones y el cálculo de los límites dentro de los cuales estas son válidas, es lo que se conoce como análisis de sensibilidad. Todo el análisis que se encuentre fuera de ese rango requeriría recalcular el modelo.

Como tal, constituye una herramienta importante en el análisis de los resultados obtenidos, sobre todo, en dos casos en particular:

1. La sensibilidad de la solución óptima ante los cambios de la disponibilidad de los recursos (lado derecho de las restricciones). Es decir, cuáles serían los límites dentro de los cuáles los resultados del modelo me permiten calcular el impacto que tiene sobre la solución óptima, el aumento o la disminución de la disponibilidad de un recurso.
2. La sensibilidad de la solución óptima ante los cambios en la utilidad unitaria o el costo unitario (coeficientes de las variables de la función objetivo). Es decir, cuáles serían los límites dentro de los cuáles los resultados del modelo me permiten calcular el impacto que tiene sobre la solución óptima, el aumento o la disminución de la utilidad unitaria o el costo unitario asociada a las variables que forman parte de la función objetivo.

Análisis de sensibilidad gráfica, caso 1: Cambios en el lado derecho (Disponibilidad de recursos)

Con el propósito de evaluar los resultados obtenidos a través del tratamiento de un problema técnicamente formulado y abordado, utilizaremos un caso descrito en el libro Investigación de Operaciones (9na edición), de Hamdy A. Taha (University of Arkansas, Fayetteville), (Ejemplo 3.6-1):

JOBCO fabrica dos productos en dos máquinas. Una unidad del producto 1 requiere 2 horas en la máquina 1, y 1 hora en la máquina 2. Una unidad del producto 2 requiere 1 hora en la máquina 1, y 3 horas en la máquina 2. Los ingresos por unidad de los productos 1 y 2 son de $30 y $20, respectivamente. El tiempo de procesamiento diario total disponible en cada máquina es de 8 horas.

Si x1 y x2 son las cantidades diarias de productos 1 y 2, respectivamente, el modelo se da como:

Zmax = 30x1 + 20x2

Sujeto a:

2x1 + x2 <= 8 (Máquina 1)

x1 + 3x2 <= 8 (Máquina 2)

x1, x2 >= 0 (No negatividad)

La forma en la que abordamos la solución gráfica de un modelo de programación lineal mediante Python, está ampliamente documentada. El código en Python que resuelve mediante método gráfico el problema anterior, lo presentamos a continuación:

# Caso JOBCO: Investigación de Operaciones (9na edición), de Hamdy A. Taha 
# (University of Arkansas, Fayetteville), (Ejemplo 3.6-1)
# Autor del código en Python: Bryan Salazar López, Ing. M.Sc. (2021)

#Librerías necesarias
import matplotlib.pyplot as plt
import numpy as np
from shapely.geometry import LineString

#Ecuaciones e intervalos (Para tabular)
x = np.arange(-20, 20, 5)
y = np.arange(-20, 20, 5)
y1 = 8 - (2 * x)
y2 = (8 - x) / 3
y3 = 0 * x
x1 = 0 * y
z = (-30 * x) / 20

#Identificadores para las líneas
primera_linea = LineString(np.column_stack((x, y1)))
segunda_linea = LineString(np.column_stack((x, y2)))
tercera_linea = LineString(np.column_stack((x, y3)))
cuarta_linea = LineString(np.column_stack((x1, y)))
quinta_linea = LineString(np.column_stack((x, z)))

#Graficando las líneas
plt.plot(x, y1, '-', linewidth=2, color='b')
plt.plot(x, y2, '-', linewidth=2, color='g')
plt.plot(x, y3, '-', linewidth=2, color='r')
plt.plot(x1, y, '-', linewidth=2, color='y')
plt.plot(x, z, ':', linewidth=1, color='k')


#Generando las intersecciones (vértices)
primera_interseccion = cuarta_linea.intersection(segunda_linea)
segunda_interseccion = primera_linea.intersection(segunda_linea)
tercera_interseccion = primera_linea.intersection(tercera_linea)
cuarta_interseccion = tercera_linea.intersection(cuarta_linea)
quinta_interseccion = cuarta_linea.intersection(primera_linea)
sexta_interseccion = segunda_linea.intersection(tercera_linea)

#Graficando los vértices
plt.plot(*primera_interseccion.xy, 'o', color='k')
plt.plot(*segunda_interseccion.xy, 'o', color='k')
plt.plot(*tercera_interseccion.xy, 'o', color='k')
plt.plot(*cuarta_interseccion.xy, 'o', color='k')
plt.plot(*quinta_interseccion.xy, 'o', color='silver')
plt.plot(*sexta_interseccion.xy, 'o', color='silver')

#Identificando los valores de las coordenadas x y y de cada vértice
xi1m, yi1m = primera_interseccion.xy
xi2m, yi2m = segunda_interseccion.xy
xi3m, yi3m = tercera_interseccion.xy
xi4m, yi4m = cuarta_interseccion.xy
xi5m, yi5m = quinta_interseccion.xy
xi6m, yi6m = sexta_interseccion.xy

#Cambiamos el formato de matriz a float
xi1 = np.float64(np.array(xi1m))
xi2 = np.float64(np.array(xi2m))
xi3 = np.float64(np.array(xi3m))
xi4 = np.float64(np.array(xi4m))
xi5 = np.float64(np.array(xi5m))
xi6 = np.float64(np.array(xi6m))
yi1 = np.float64(np.array(yi1m))
yi2 = np.float64(np.array(yi2m))
yi3 = np.float64(np.array(yi3m))
yi4 = np.float64(np.array(yi4m))
yi5 = np.float64(np.array(yi5m))
yi6 = np.float64(np.array(yi6m))

#literales de las intersecciones (nombres en el gráfico)
plt.annotate(' A', (xi4, yi4))
plt.annotate(' B', (xi1, yi1))
plt.annotate(' C', (xi2, yi2))
plt.annotate(' D', (xi3, yi3))
plt.annotate(' E', (xi5, yi5))
plt.annotate(' F', (xi6, yi6))

#Evaluando la función objetivo en cada vértice
FOi1 = (xi1 * 30) + (yi1 * 20)
FOi2 = (xi2 * 30) + (yi2 * 20)
FOi3 = (xi3 * 30) + (yi3 * 20)
FOi4 = (xi4 * 30) + (yi4 * 20)

#Calculando el mejor resultado (Maximizar)
ZMAX = max(FOi1, FOi2, FOi3, FOi4)

#Imprimiendo la solución óptima en la consola
print('\n SOLUCIÓN ÓPTIMA')
print('Solución óptima: {} '.format(ZMAX))

#Ordenando las coordenadas de los vértices (Las coordenadas x en m y las coordenadas y en n)
m = [xi1, xi2, xi3, xi4]
n = [yi1, yi2, yi3, yi4]

#Graficando el polígono solución a partir de las coordenadas de los vértices (importante el orden según las manecillas)
plt.fill(m, n, color='silver')

#Identificando el índice del vértice de la mejor solución
dict1 = {0:FOi1, 1:FOi2, 2:FOi3, 3:FOi4}
posicion = max(dict1, key=dict1.get)

#Obteniendo las coordenadas del vértice de la mejor solución de acuerdo al índice del paso anterior
XMAX = m[posicion]
YMAX = n[posicion]

#Imprimiendo las coordenadas del vértice de la mejor solución (variables de decisión)
print('\n VARIABLES DE DECISIÓN')
print('Cantidad de producto X1 a producir: {} unidades'.format(XMAX))
print('Cantidad de producto X2 a producir: {} unidades'.format(YMAX))

#Configuraciones adicionales del gráfico
plt.grid()
plt.xlabel('X1')
plt.ylabel('X2')
plt.title('JOBCO')

plt.show()

Al ejecutar este código, de acuerdo a las instrucciones que pueden encontrar en el artículo de introducción al método gráfico mediante Python, obtendrán:

Así mismo, el siguiente resultado en la consola:

Así entonces, tenemos establecido el código base sobre el cual abordaremos este primer caso de análisis de sensibilidad: cambios en el lado derecho (disponibilidad de recursos).

La pregunta que pretende responder este caso de análisis de sensibilidad es ¿Qué pasaría con la función objetivo si cambia la disponibilidad de alguno de los recursos del problema? El cual corresponde a un planteamiento muy lógico de análisis, puesto que nos ampliaría la información relevante para la toma de decisiones.

Acercando este interrogante a nuestro problema de ejemplo, la cuestión podría ser: ¿Qué pasaría con los ingresos totales si la máquina 1 cambia su capacidad?

Pensemos por un momento cómo podemos abordar este planteamiento de manera gráfica, pensemos por un momento cómo podemos utilizar nuestro código base para abordar este caso.

Y bien, se nos puede ocurrir en primer lugar, graficar la nueva línea que represente la nueva función de disponibilidad de la máquina 1. Recordemos que si la restricción base es la siguiente:

2x1 + x2 <= 8 (Máquina 1)

Un incremento en la capacidad (variación), por ejemplo, se representaría mediante la siguiente inecuación:

2x1 + x2 <= 8 + 1

Esto quiere decir que, la nueva disponibilidad de la máquina 1 pasará de 8 horas a 9 horas. Y nuestro razonamiento nos indica que esta función, tendrá una representación distinta a la anterior, por ende sería de mucha utilidad graficarla. Veamos el código para adicionar en Python:

#Ecuaciones e intervalos (Para tabular)
x = np.arange(-20, 20, 5)
y = np.arange(-20, 20, 5)
y1 = 8 - (2 * x)
y2 = (8 - x) / 3
y3 = 0 * x
x1 = 0 * y
z = (-30 * x) / 20
y1v = (8 + 1) - (2 * x) #Variación en la máquina 1 (8 + 1)

#Identificadores para las líneas
primera_linea = LineString(np.column_stack((x, y1)))
segunda_linea = LineString(np.column_stack((x, y2)))
tercera_linea = LineString(np.column_stack((x, y3)))
cuarta_linea = LineString(np.column_stack((x1, y)))
quinta_linea = LineString(np.column_stack((x, z)))
sexta_linea = LineString(np.column_stack((x, y1v))) #Nueva línea

#Graficando las líneas
plt.plot(x, y1, '-', linewidth=2, color='b')
plt.plot(x, y2, '-', linewidth=2, color='g')
plt.plot(x, y3, '-', linewidth=2, color='r')
plt.plot(x1, y, '-', linewidth=2, color='y')
#plt.plot(x, z, ':', linewidth=1, color='k') #Podemos ocultar esta línea (FO)
plt.plot(x, y1v, ':', linewidth=1, color='b') #Nueva línea

Podemos observar cómo agregamos tan solo 3 líneas de código, mediante la inclusión de la variable y1v (variación de la ecuación de la máquina 1).

La ecuación con la cual se representa la restricción de la máquina 1 corresponde a la siguiente:

y1 = 8 – (2 * x)

Por ende, lo que hacemos es aumentar la capacidad de la máquina 1 (8) a una nueva capacidad (9 = 8 + 1):

y1v = (8 + 1) – (2 * x)

Las dos líneas de código adicionales graficarán esta nueva ecuación.

Al ejecutar nuestro código tendremos:

En este caso, podemos observar cómo una variación en la disponibilidad del recurso 1 (máquina 1), se representa con una línea recta (línea azul punteada) que conserva la misma pendiente de la restricción 1 (línea azul continua), que se mueve paralela a ella, y que en consecuencia, genera una nueva intersección solución (intersección con la restricción 2 – línea verde).

En este nuevo vértice solución se encuentra un nuevo punto óptimo, es decir, una coordenada diferente en la cual al evaluar la función objetivo, tendremos la respuesta al interrogante planteado: ¿Qué pasaría con los ingresos totales si la máquina 1 cambia su capacidad?

En consecuencia, utilizaremos nuestro código para:

El siguiente fragmento muestra detalladamente las adiciones al código base:

#Generando las intersecciones (vértices)
primera_interseccion = cuarta_linea.intersection(segunda_linea)
segunda_interseccion = primera_linea.intersection(segunda_linea)
tercera_interseccion = primera_linea.intersection(tercera_linea)
cuarta_interseccion = tercera_linea.intersection(cuarta_linea)
quinta_interseccion = cuarta_linea.intersection(primera_linea)
sexta_interseccion = segunda_linea.intersection(tercera_linea)
septima_interseccion = sexta_linea.intersection(segunda_linea) #Nuevo vértice

#Graficando los vértices
plt.plot(*primera_interseccion.xy, 'o', color='k')
plt.plot(*segunda_interseccion.xy, 'o', color='k')
plt.plot(*tercera_interseccion.xy, 'o', color='k')
plt.plot(*cuarta_interseccion.xy, 'o', color='k')
plt.plot(*quinta_interseccion.xy, 'o', color='silver')
plt.plot(*sexta_interseccion.xy, 'o', color='silver')
plt.plot(*septima_interseccion.xy, 'o', color='k') #Graficar nuevo vértice

#Identificando los valores de las coordenadas x y y de cada vértice
xi1m, yi1m = primera_interseccion.xy
xi2m, yi2m = segunda_interseccion.xy
xi3m, yi3m = tercera_interseccion.xy
xi4m, yi4m = cuarta_interseccion.xy
xi5m, yi5m = quinta_interseccion.xy
xi6m, yi6m = sexta_interseccion.xy
xi7m, yi7m = septima_interseccion.xy #Coordenadas del nuevo vértice

#Cambiamos el formato de matriz a float
xi1 = np.float64(np.array(xi1m))
xi2 = np.float64(np.array(xi2m))
xi3 = np.float64(np.array(xi3m))
xi4 = np.float64(np.array(xi4m))
xi5 = np.float64(np.array(xi5m))
xi6 = np.float64(np.array(xi6m))
xi7 = np.float64(np.array(xi7m)) #Nueva coordenada en x
yi1 = np.float64(np.array(yi1m))
yi2 = np.float64(np.array(yi2m))
yi3 = np.float64(np.array(yi3m))
yi4 = np.float64(np.array(yi4m))
yi5 = np.float64(np.array(yi5m))
yi6 = np.float64(np.array(yi6m))
yi7 = np.float64(np.array(yi7m)) #Nueva coordenada en y

#literales de las intersecciones (nombres en el gráfico)
plt.annotate(' A', (xi4, yi4))
plt.annotate(' B', (xi1, yi1))
plt.annotate(' C', (xi2, yi2))
plt.annotate(' D', (xi3, yi3))
plt.annotate(' E', (xi5, yi5))
plt.annotate(' F', (xi6, yi6)) 
plt.annotate(' G', (xi7, yi7)) #Nombrar el nuevo vértice como G

#Evaluando la función objetivo en cada vértice
FOi1 = (xi1 * 30) + (yi1 * 20)
FOi2 = (xi2 * 30) + (yi2 * 20)
FOi3 = (xi3 * 30) + (yi3 * 20)
FOi4 = (xi4 * 30) + (yi4 * 20)
FOi4 = (xi7 * 30) + (yi7 * 20) #Calcular la FO en el nuevo vértice

#Imprimiendo la solución óptima en la consola
print('\n SOLUCIÓN ÓPTIMA')
print('Solución óptima: {} '.format(ZMAX))
print('Función objetivo en punto G: {} '.format(FOi7)) #Mostrar la FO en el punto G

Lo que realizamos es muy sencillo, es decir, ya que tenemos una nueva línea, realizamos los mismos procedimientos para identificar y graficar el nuevo vértice generado. Al ejecutar el código obtendremos lo siguiente:

La figura 5 ilustra el cambio de la solución óptima cuando se cambia la capacidad de la máquina 1. Si la capacidad diaria se incrementa de 8 a 9 horas, el nuevo óptimo se moverá al punto G. Los resultados que se pueden apreciar en la consola, nos permiten conocer que el valor de la función objetivo evaluada en el punto G (z en G) equivale a 142,0. Es decir, un valor superior a 128,0 (z en C).

Con los datos obtenidos podemos establecer en este caso la tasa de cambio en la función objetivo a consecuencia del cambio de la capacidad de la máquina 1 de 8 a 9 horas. Esta tasa de cambio se denomina de diversas formas: valor unitario de un recurso (Taha); precio dual (múltiples solucionadores); shadow price (precio sombra).

Esta tasa representa el impacto del incremento unitario en la capacidad de un recurso en la función objetivo; se calcula de la siguiente manera:

En nuestro ejemplo se calculará así:

Esto indica que: Un incremento unitario en la capacidad de la máquina 1, aumentará el ingreso en $14,0. O lo que es igual: Una reducción unitaria en la capacidad de la máquina 1, reducirá el ingreso en $14,0.

En lo que concierne a nuestro código e Python, es sencillo, resulta que nosotros ya tenemos la función objetivo evaluada en cada uno de los vértices del gráfico. Así entonces, será cuestión de crear una nueva variable que represente el precio dual y la operación correspondiente:

#Precio dual (Restricción 1)
Dual1 = (FOi7 - ZMAX) #Calculamos el precio dual para la restricción 1

print('\n ANÁLISIS DE SENSIBILIDAD')
print('Precio dual de la máquina 1: {} $/h'.format(Dual1)) #Imprimimos el precio dual 1

Recordemos que la función objetivo del punto G (z en G) se representa por la variable FOi7 (función objetivo en la intersección 7). La operación efectúa la diferencia entre este valor y la función objetivo en el vértice óptimo base (ZMAX).

Al ejecutar el código obtendremos lo siguiente en la consola de Windows:

Ahora bien, debemos recordar que hemos hecho énfasis en que el análisis de sensibilidad del caso 1 (cambios en el lado derecho de las restricciones – capacidad de los recursos), precisa de unos límites dentro de los cuáles los resultados del modelo me permiten calcular el impacto que tiene sobre la solución óptima. Es decir, para nuestro caso en particular: los límites dentro de los cuales el precio dual para la máquina 1 es 14$/h. Dicho de otra manera, estamos en condiciones de calcular el impacto de una variación en la máquina 1 en los ingresos totales, pero, ¿Hasta cuándo esa proyección es válida? Y sí, existen unos límites dentro de los cuales nuestra proyección, tasa o precio dual es válido, por fuera de ellos, sería necesario recalcular.

Revisemos nuevamente la figura 4:

Veamos cómo la línea que representa los cambios en la capacidad de la máquina 1 (recurso) se mueve paralela a sí misma, y bien puede hacerlo sobre el segmento de la línea que representa la capacidad de la máquina 2 (línea verde, o algebraicamente: línea BF, desde el punto B hasta el punto F). Esa es básicamente la clave para determinar los límites de validez de nuestro precio dual, mejor conocidos como intervalos de factibilidad. Pero ¿Cuál es la clave? Sí, la ecuación de la máquina 1 puede moverse para formar una intersección con la línea verde (a medida que cambie su capacidad) entre B y F, de manera que en estos vértices se encuentran los límites. Y para ser directos, la idea consiste en calcular la capacidad de la máquina 1 en cada uno de estos vértices. ¿Cómo lo hacemos? Veamos:

La ecuación que representa la capacidad de la máquina 1 está dada por:

2x1 + x2 <= 8 horas (máquina 1)

Por ende, si retiramos el valor de la capacidad del recurso (8 horas), obtendremos la ecuación de la utilización o el uso del recurso:

2x1 + x2 = Utilización o uso de la máquina 1

Ahora, teniendo la ecuación de la restricción 1 (máquina 1), podemos evaluar cuál sería su utilización en los vértices B y F. Así encontraríamos los límites de validez para esta restricción (intervalos de factibilidad para nuestro precio dual = 14$/h). Dicho de otro modo, encontraríamos la capacidad mínima y máxima de la máquina 1, para que una variación unitaria en la disponibilidad de la misma (máquina 1), represente una variación de 14$ en la función objetivo. Por fuera de ese intervalo, no podemos asegurar de ninguna manera que el precio dual es de 14$/h, sería necesario recalcular.

Volvamos a la determinación de los límites. Ya tenemos la ecuación de la restricción (la verdad, siempre la hemos tenido), ahora la evaluaremos en los puntos B y F. Para ello es preciso conocer las coordenadas de cada uno de estos puntos. En Python podemos utilizar el siguiente fragmento:

#Intervalos de factibilidad
IFmin1 = (2 * xi2) + yi2
IFmax1 = (2 * xi6) + yi6

print('Límite mínimo de factibilidad (PD máquina 1): {} h'.format(IFmin1))
print('Límite máximo de factibilidad (PD máquina 1): {} h'.format(IFmax1))

Veamos: El punto B según nuestro código, corresponde a la segunda intersección, por ende sus coordenadas están definidas por las variables xi1 y yi1. Así entonces, evaluamos la capacidad de la máquina 1 en estas coordenadas y tenemos el límite mínimo de factibilidad para el precio dual de la máquina 1 (IFmin1).

Así mismo, el punto F según nuestro código, corresponde a la sexta intersección, por ende sus coordenadas están definidas por las variables xi6 y yi6. Así entonces, evaluamos la capacidad de la máquina 1 en estas coordenadas y tenemos el límite mínimo de factibilidad para el precio dual de la máquina 1 (IFmax1).

Al ejecutar el código obtendremos lo siguiente en la consola de Windows:

Podemos efectuar nosotros mismos los cálculos correspondientes:

El punto B tiene la siguientes coordenadas (x = 0, y = 2,67)

Evaluando estas coordenadas en la ecuación de la máquina 1, tenemos:

2(0)+ (2,67) = Límite mínimo de factibilidad (máquina 1)

2(0)+ (2,67) = 2,67 horas

El punto F tiene la siguientes coordenadas (x = 8, y = 0)

Evaluando estas coordenadas en la ecuación de la máquina 1, tenemos:

2(8)+ (0) = Límite máximo de factibilidad (máquina 1)

2(8)+ (0) = 16 horas

Ya efectuamos los procedimientos de manera manual y mediante Python. La conclusión es que el precio dual de $14/h permanece válido en el intervalo:

2,67 h <= Capacidad de la máquina 1 <= 16 h

Los cambios que se encuentren fuera de esos intervalos de factibilidad producen un precio dual diferente, y por lo tanto, precisan nuevos cálculos.

En nuestro código, incluiremos las líneas que permitan llegar al precio dual y a los intervalos de factibilidad de la máquina 2. Al ejecutarlo, obtendremos lo siguiente:

La conclusión es que el precio dual de $2/h permanece válido en el intervalo:

4 h <= Capacidad de la máquina 2 <= 24 h

Los precios duales y los intervalos de factibilidad amplían la base que ofrece la solución óptima para la toma de decisiones. Taha propone una serie de preguntas alrededor de este caso (ejercicio 3.6-1), que pueden ser abordadas gracias al análisis de sensibilidad.

Pregunta 1: Si JOBCO puede incrementar la capacidad de ambas máquinas, ¿Cuál máquina tendrá la prioridad?

Respuesta: De acuerdo a los precios duales para las máquinas 1 y 2, cada hora adicional de la máquina 1 incrementa el ingreso total en $14; mientras tanto, cada hora adicional de la máquina 2 incrementa el ingreso total en $2. Por lo tanto, la máquina 1 debe tener la prioridad.

Pregunta 2: Se sugiere incrementar las capacidades de las máquinas 1 y 2 al costo adicional de $10/h para cada máquina. ¿Es esto aconsejable?

Respuesta: De acuerdo a los precios duales para las máquinas 1 y 2.  Los ingresos netos adicionales por hora serían de la siguiente manera:

Máquina 1:

14$/h (Precio dual máquina 1) – 10$/h (Costo para aumentar capacidad) = 4 $/h (Ingreso neto)

Máquina 2:

2$/h (Precio dual máquina 2) – 10$/h (Costo para aumentar capacidad) = – 8 $/h (Ingreso neto)

Por consiguiente, solo la máquina 1 debe considerarse para el incremento de capacidad.

Pregunta 3: Si la capacidad de la máquina 1 se incrementa de 8 a 13 horas, ¿Cómo impactará este incremento al ingreso óptimo?

Respuesta: Lo primero que debe evaluarse es que la nueva capacidad de la máquina 1 se encuentre dentro del intervalo de factibilidad (2,67 h – 16 h). Ya que sí se encuentra en dicho intervalo (13 h), el siguiente paso consiste en calcular el cambio en la disponibilidad:

Cambio en la capacidad = 13 (Nueva capacidad) – 8 (Capacidad inicial)

Cambio en la capacidad = 5 horas

Por ende, multiplicamos dicho cambio por la tasa de cambio del ingreso (precio dual):

Cambio en el ingreso = Precio dual  * Cambio en la capacidad

Cambio en el ingreso = 14 $/h * (5 horas)

Cambio en el ingreso = 70 $

Nuevo ingreso = Ingreso base (Solución óptima) + Cambio en el ingreso

Nuevo ingreso = $ 128 + $ 70

Nuevo ingreso = $ 198

En el caso de que la nueva capacidad de la máquina se encuentre por fuera del intervalo de factibilidad para dicho recurso, no se dispondría de información suficiente para llegar a una conclusión válida.

A continuación, dejamos a disposición el código completo del análisis de sensibilidad gráfica desarrollado en Python:

# Caso 1: Investigación de Operaciones (9na edición), de Hamdy A. Taha 
# (University of Arkansas, Fayetteville), (Ejemplo 3.6-1)
# Autor del código en Python: Bryan Salazar López, Ing. M.Sc. (2021)

#Librerías necesarias
import matplotlib.pyplot as plt
import numpy as np
from shapely.geometry import LineString

#Ecuaciones e intervalos (Para tabular)
x = np.arange(-20, 20, 5)
y = np.arange(-20, 20, 5)
y1 = 8 - (2 * x)
y2 = (8 - x) / 3
y3 = 0 * x
x1 = 0 * y
z = (-30 * x) / 20
y1v = (8 + 1) - (2 * x) #Variación en la máquina 1 (8 + 1)
y2v = ((8 + 1) - x) / 3 #Variación en la máquina 2 (8 + 1)

#Identificadores para las líneas
primera_linea = LineString(np.column_stack((x, y1)))
segunda_linea = LineString(np.column_stack((x, y2)))
tercera_linea = LineString(np.column_stack((x, y3)))
cuarta_linea = LineString(np.column_stack((x1, y)))
quinta_linea = LineString(np.column_stack((x, z)))
sexta_linea = LineString(np.column_stack((x, y1v))) #Nueva línea Máquina 1 (M1)
septima_linea = LineString(np.column_stack((x, y2v))) #Nueva línea Máquina 2 (M2)

#Graficando las líneas
plt.plot(x, y1, '-', linewidth=2, color='b')
plt.plot(x, y2, '-', linewidth=2, color='g')
plt.plot(x, y3, '-', linewidth=2, color='r')
plt.plot(x1, y, '-', linewidth=2, color='y')
#plt.plot(x, z, ':', linewidth=1, color='k')
plt.plot(x, y1v, ':', linewidth=1, color='b') #Nueva línea M1
plt.plot(x, y2v, ':', linewidth=1, color='g') #Nueva línea M2


#Generando las intersecciones (vértices)
primera_interseccion = cuarta_linea.intersection(segunda_linea)
segunda_interseccion = primera_linea.intersection(segunda_linea)
tercera_interseccion = primera_linea.intersection(tercera_linea)
cuarta_interseccion = tercera_linea.intersection(cuarta_linea)
quinta_interseccion = cuarta_linea.intersection(primera_linea)
sexta_interseccion = segunda_linea.intersection(tercera_linea)
septima_interseccion = sexta_linea.intersection(segunda_linea) #Nuevo vértice M1
octava_interseccion = septima_linea.intersection(primera_linea) #Nuevo vértice M2

#Graficando los vértices
plt.plot(*primera_interseccion.xy, 'o', color='k')
plt.plot(*segunda_interseccion.xy, 'o', color='k')
plt.plot(*tercera_interseccion.xy, 'o', color='k')
plt.plot(*cuarta_interseccion.xy, 'o', color='k')
plt.plot(*quinta_interseccion.xy, 'o', color='silver')
plt.plot(*sexta_interseccion.xy, 'o', color='silver')
plt.plot(*septima_interseccion.xy, 'o', color='k') #Graficar nuevo vértice M1
plt.plot(*octava_interseccion.xy, 'o', color='k') #Graficar nuevo vértice M2

#Identificando los valores de las coordenadas x y y de cada vértice
xi1m, yi1m = primera_interseccion.xy
xi2m, yi2m = segunda_interseccion.xy
xi3m, yi3m = tercera_interseccion.xy
xi4m, yi4m = cuarta_interseccion.xy
xi5m, yi5m = quinta_interseccion.xy
xi6m, yi6m = sexta_interseccion.xy
xi7m, yi7m = septima_interseccion.xy #Coordenadas del nuevo vértice M1
xi8m, yi8m = octava_interseccion.xy #Coordenadas del nuevo vértice M2

#Cambiamos el formato de matriz a float
xi1 = np.float64(np.array(xi1m))
xi2 = np.float64(np.array(xi2m))
xi3 = np.float64(np.array(xi3m))
xi4 = np.float64(np.array(xi4m))
xi5 = np.float64(np.array(xi5m))
xi6 = np.float64(np.array(xi6m))
xi7 = np.float64(np.array(xi7m)) #Nueva coordenada en x (Máquina 1)
xi8 = np.float64(np.array(xi8m)) #Nueva coordenada en x (Máquina 2)
yi1 = np.float64(np.array(yi1m))
yi2 = np.float64(np.array(yi2m))
yi3 = np.float64(np.array(yi3m))
yi4 = np.float64(np.array(yi4m))
yi5 = np.float64(np.array(yi5m))
yi6 = np.float64(np.array(yi6m))
yi7 = np.float64(np.array(yi7m)) #Nueva coordenada en y (Máquina 1)
yi8 = np.float64(np.array(yi8m)) #Nueva coordenada en y (Máquina 2)

#literales de las intersecciones (nombres en el gráfico)
plt.annotate(' A', (xi4, yi4))
plt.annotate(' B', (xi1, yi1))
plt.annotate(' C', (xi2, yi2))
plt.annotate(' D', (xi3, yi3))
plt.annotate(' E', (xi5, yi5))
plt.annotate(' F', (xi6, yi6)) 
plt.annotate(' G', (xi7, yi7)) #Nombrar el nuevo vértice como G
plt.annotate(' H', (xi8, yi8)) #Nombrar el nuevo vértice como H

#Evaluando la función objetivo en cada vértice
FOi1 = (xi1 * 30) + (yi1 * 20)
FOi2 = (xi2 * 30) + (yi2 * 20)
FOi3 = (xi3 * 30) + (yi3 * 20)
FOi4 = (xi4 * 30) + (yi4 * 20)
FOi7 = (xi7 * 30) + (yi7 * 20) #Calcular la FO en el nuevo vértice G
FOi8 = (xi8 * 30) + (yi8 * 20) #Calcular la FO en el nuevo vértice H

#Calculando el mejor resultado (Maximizar)
ZMAX = max(FOi1, FOi2, FOi3, FOi4)

#Imprimiendo la solución óptima en la consola
print('\n SOLUCIÓN ÓPTIMA')
print('Solución óptima: {} '.format(ZMAX))
print('Función objetivo en punto G: {} '.format(FOi7))
print('Función objetivo en punto H: {} '.format(FOi8))

#Ordenando las coordenadas de los vértices (Las coordenadas x en m y las coordenadas y en n)
m = [xi1, xi2, xi3, xi4]
n = [yi1, yi2, yi3, yi4]

#Graficando el polígono solución a partir de las coordenadas de los vértices (importante el orden según las manecillas)
plt.fill(m, n, color='silver')

#Identificando el índice del vértice de la mejor solución
dict1 = {0:FOi1, 1:FOi2, 2:FOi3, 3:FOi4}
posicion = max(dict1, key=dict1.get)

#Obteniendo las coordenadas del vértice de la mejor solución de acuerdo al índice del paso anterior
XMAX = m[posicion]
YMAX = n[posicion]

#Imprimiendo las coordenadas del vértice de la mejor solución (variables de decisión)
print('\n VARIABLES DE DECISIÓN')
print('Cantidad de producto X1 a producir: {} unidades'.format(XMAX))
print('Cantidad de producto X2 a producir: {} unidades'.format(YMAX))

#Precio dual (Restricción 1)
Dual1 = (FOi7 - ZMAX) #Calculamos el precio dual para la restricción 1
Dual2 = (FOi8 - ZMAX) #Calculamos el precio dual para la restricción 1

#Imprimir los precios duales
print('\n ANÁLISIS DE SENSIBILIDAD')
print('Precio dual de la máquina 1: {} $/h'.format(Dual1)) #Imprimimos el precio dual 1
print('Precio dual de la máquina 2: {} $/h'.format(Dual2)) #Imprimimos el precio dual 2

#Intervalos de factibilidad (Máquina 1)
IFmin1 = (2 * xi1) + yi1
IFmax1 = (2 * xi6) + yi6

#Intervalos de factibilidad (Máquina 2)
IFmin2 = xi3 + (3 * yi3)
IFmax2 = xi5 + (3 * yi5)

#Imprimir los intervalos de factibilidad
print('\n INTERVALOS DE FACTIBILIDAD')
print('Límite mínimo de factibilidad (PD máquina 1): {} h'.format(IFmin1))
print('Límite máximo de factibilidad (PD máquina 1): {} h'.format(IFmax1))
print('Límite mínimo de factibilidad (PD máquina 2): {} h'.format(IFmin2))
print('Límite máximo de factibilidad (PD máquina 2): {} h'.format(IFmax2))


#Configuraciones adicionales del gráfico
plt.grid()
plt.xlabel('X1')
plt.ylabel('X2')
plt.title('JOBCO')

plt.show()

En el próximo artículo desarrollaremos el segundo caso de análisis de sensibilidad: cambios en la utilidad unitaria o el costo unitario.

La entrada Análisis de sensibilidad gráfica mediante el uso de Python (Caso 1) se publicó primero en Ingenieria Industrial Online.