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.

Podemos decir que el problema o algoritmo de la ruta más corta es una popularización del problema del flujo del costo mínimo, una variación de los modelos generales de flujos. Cuando nos referimos al costo mínimo, este en realidad puede expresarse en diversas magnitudes: distancia, tiempo, volumen, y en general, cual cualquier unidad que represente el caso de estudio.

En el problema del flujo de costo mínimo, cada arco de la red tiene un costo asociado a transportar unidades a través de él, es decir, por ejemplo, que el arco que une a los nodos 0 y 1, tiene un costo subyacente a su transporte, en los términos que representen mejor al modelo. Además del costo, cada arco debe considerar una capacidad de transporte.

Del mismo modo, debe considerarse que en este problema los nodos tienen una naturaleza, y existen algunos nodos especiales:

En el anterior gráfico se puede apreciar una representación básica de lo que sería la naturaleza de los nodos aplicada a un caso común: una planta que produce material, lo envía hacia algunos centros de distribución o consolidación y un cliente, lugar que representa el destino final del material. Claramente pueden apreciarse cuales son los nodos de oferta, de demanda y de tránsito. Ahora bien, es posible que en la práctica existan múltiples nodos de oferta y múltiples nodos de demanda, del mismo modo, es posible que los nodos de tránsito también suministren o consuman unidades, lo que los convertiría en nodos mixtos, y lo que podría representar múltiples casos prácticos, por ejemplo: un centro de distribución ubicado en una planta, el cual recibe unidades para consumo interno y despacha excedentes hacia otros centros o clientes.

Problema de la ruta más corta

Tal como se mencionó en la introducción del artículo, el problema de la ruta más corta puede abordarse desde la perspectiva del problema del flujo de costo mínimo, en el cual el objetivo consiste en determinar el plan de rutas que genere la trayectoria con la mínima distancia total, que una un nodo fuente (puro) con un nodo destino (puro), sin importar el número de nodos que existan entre estos.

Así entonces, en su versión más básica, el flujo y la capacidad de los arcos puede reducirse a la unidad (1), asumiendo que no se transportan materiales y que el único objetivo que se persigue consiste en determinar la ruta más corta que une a un nodo fuente con un nodo destino. Dicho de otro modo, el nodo fuente produce una unidad que es transportada por medio de arcos con capacidad de unidad y se consume en la medida de una unidad en el nodo destino.

Es preciso reiterar que cuando nos referimos distancia nos ajustamos al nombre del algoritmo «la ruta más corta», sin embargo, lo que se considera distancia, bien puede expresarse en otras unidades de medida, por ejemplo: costo.

El objetivo de este artículo consiste en utilizar las librerías del software Google OR-Tools para abordar el problema de la ruta más corta a través de una interfaz base del algoritmo del flujo de costo mínimo. Posteriormente, abordaremos un script básico en Python que nos permita integrar al modelo de optimización, data de entrada proveniente de fuentes como un documento de Excel.

El problema

Con el propósito de evaluar los resultados obtenidos mediante distintos métodos y solucionadores, utilizaremos el mismo problema que abordamos mediante programación lineal y el módulo de network modeling de WinQSB.

Un minero ha quedado atrapado en una mina, la entrada a la mina se encuentra ubicada en el nodo 0, se conoce de antemano que el minero permanece atrapado en el nodo 8, para llegar a dicho nodo hay que atravesar una red de túneles que van conectados entre sí. El tiempo de vida que le queda al minero sin recibir auxilio es cada vez menor y se hace indispensable hallar la ruta de acceso al nodo 8 más corta. Las distancias entre nodos de la mina se encuentran en la siguiente gráfica dadas en cientos de metros:

Resolviendo un problema de la ruta más corta mediante Google OR-Tools

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.

Es posible que para la ejecución de este script, debas instalar el comando future, el cual puedes encontrar en el siguiente enlace: future 0.18.2. La instalación es muy simple, tan solo escribir en el cmd (símbolo del sistema) lo siguiente:

pip install future

Paso 1: Importar la librería

El siguiente fragmento de código importa las librerías necesarias:

# Importar la librería de Google OR-Tools
from __future__ import print_function
from ortools.graph import pywrapgraph

Paso 2: Crear la data del modelo

Define cuatro matrices paralelas: nodos_fuente, nodos_destino, capacidades, y costos_unitarios, entre cada par. Por ejemplo, el arco desde el nodo 0 hacia el nodo 1 tiene una capacidad de 1 y un costo asociado de 4 (distancia). En su versión más básica el objetivo consiste en unir un nodo fuente y un nodo destino; por esta razón, en este ejemplo la capacidad de todos los nodos equivale a 1 y el flujo es binario, donde tomará valores de 1 en el caso en que el arco forme parte del conjunto solución y 0 en el caso contrario:

Pueden observarse las matrices perfectamente alineadas, ya que el orden es importante. El orden entre la matriz de nodos_fuente y nodos_destino definirá el valor de los arcos del modelo (distancia).

nodos_fuente  = [ 0, 0, 1, 1, 2, 2, 2, 3, 3, 4, 4, 4, 5, 5, 6, 6, 6, 7, 7]
nodos_destino = [ 1, 2, 2, 3, 1, 3, 4, 5, 6, 3, 6, 7, 6, 8, 5, 7, 8, 6, 8]
capacidades   = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
distancia     = [ 4, 2, 2, 7, 4, 9, 6, 1, 5, 2, 3, 2, 1, 5, 4, 3, 6, 2, 6]

suministros = [1, 0, 0, 0, 0, 0, 0, 0, -1]

También definimos la matriz de suministros asociada a los nodos, donde los valores positivos corresponde a oferta y los valores positivos corresponde a demanda. Los ceros se asocian a los nodos de tránsito. En nuestro ejemplo solo existe un nodo de oferta = nodo 0, y un nodo de demanda = nodo 8.

Paso 3: Declarar el solucionador y agregar los arcos del modelo

El siguiente fragmento define en primera instancia el solucionador (declara). Luego, define cada arco del problema, es decir, con base en las matrices definidas como datos de entrada (en su orden), establece el valor (costo = distancia) de cada arco. Posteriormente, define los suministros (o demandas) para cada nodo.

# Crea una instancia para el solucionador
min_cost_flow = pywrapgraph.SimpleMinCostFlow()

# Define cada arco del problema
for i in range(0, len(nodos_fuente)):
  min_cost_flow.AddArcWithCapacityAndUnitCost(nodos_fuente[i], nodos_destino[i],
                                              capacidades[i], distancia[i])

# Define los suministros para cada nodo.
for i in range(0, len(suministros)):
  min_cost_flow.SetNodeSupply(i, suministros[i])

Paso 4: Invocar al solucionador y definir la información de salida del modelo

El siguiente fragmento de código utiliza las librerías predeterminadas de Google OR-Tools para abordar problemas de flujo de costo mínimo. Así mismo, se especifican las salidas del solucionador: arco / flujo / capacidad  / distancia, para cada arco; y distancia total de la red.

# Encuentra el costo mínimo entre el nodo 0 y el nodo 8
if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:
  print('Distancia mínima:', min_cost_flow.OptimalCost())
  print('')
  print(' Arco Flujo / Capacidad Distancia')
  for i in range(min_cost_flow.NumArcs()):
    cost = min_cost_flow.Flow(i) * min_cost_flow.UnitCost(i)
    print('%1s -> %1s %3s / %3s %3s' % (
        min_cost_flow.Tail(i),
        min_cost_flow.Head(i),
        min_cost_flow.Flow(i),
        min_cost_flow.Capacity(i),
        cost))
else:
  print('Hubo un problema con la entrada de flujo de distancia mínima.')

Es posible que el desarrollo de los cuatro pasos anteriores demande algún grado de complejidad subyacente del uso de un lenguaje de programación; sin embargo, es preciso mencionar que, el modelo anterior queda perfectamente configurado, y puede replicarse con modificaciones menores en múltiples problemas de asignación.

¿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, así mismo debemos contar con la última versión del comando pip 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. También puedes ver el cuaderno de este módulo en nuestro Colaboratory: Ruta más corta.

#Desde: Salazar, ingenieriaindustrialonline.com - Algoritmo de la ruta más corta

from __future__ import print_function
from ortools.graph import pywrapgraph

def main():
  """MinCostFlow adaptado a la ruta más corta - interfaz de ejemplo."""

  # Define cuatro matrices paralelas: nodos_fuente, nodos_destino, 
  # capacidades, y costos_unitarios entre cada par.

  nodos_fuente      = [ 0, 0, 1, 1, 2, 2, 2, 3, 3, 4, 4, 4, 5, 5, 6, 6, 6, 7, 7]
  nodos_destino     = [ 1, 2, 2, 3, 1, 3, 4, 5, 6, 3, 6, 7, 6, 8, 5, 7, 8, 6, 8]
  capacidades       = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
  distancia         = [ 4, 2, 2, 7, 4, 9, 6, 1, 5, 2, 3, 2, 1, 5, 4, 3, 6, 2, 6]

  # Define una matriz con los suministros de cada nodo (valores positivos = 
  # suministros) y (valores negativos = demandas)

  suministros = [1, 0, 0, 0, 0, 0, 0, 0, -1]


  # Crea una instancia para el solucionador
  min_cost_flow = pywrapgraph.SimpleMinCostFlow()

  # Define cada arco del problema
  for i in range(0, len(nodos_fuente)):
    min_cost_flow.AddArcWithCapacityAndUnitCost(nodos_fuente[i], nodos_destino[i],
                                                capacidades[i], distancia[i])

  # Define los suministros para cada nodo.

  for i in range(0, len(suministros)):
    min_cost_flow.SetNodeSupply(i, suministros[i])


  # Encuentra el costo mínimo entre el nodo 0 y el nodo 8
  if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:
    print('Distancia mínima:', min_cost_flow.OptimalCost())
    print('')
    print('  Arco    Flujo / Capacidad  Distancia')
    for i in range(min_cost_flow.NumArcs()):
      cost = min_cost_flow.Flow(i) * min_cost_flow.UnitCost(i)
      print('%1s -> %1s    %3s   / %3s       %3s' % (
          min_cost_flow.Tail(i),
          min_cost_flow.Head(i),
          min_cost_flow.Flow(i),
          min_cost_flow.Capacity(i),
          cost))
  else:
    print('Hubo un problema con la entrada de flujo de distancia mínima.')

if __name__ == '__main__':
  main()

Y bien, tenemos la solución a este problema simple de asignación en menos de 1 segundo.

Podemos observar que se ha obtenido la misma respuesta que la lograda mediante programación lineal y el módulo de network modeling  de WinQSB:

Problema de la ruta más corta mediante Google OR-Tools, importando los datos desde Excel

Tal como lo planteamos al inicio del artículo, abordaremos un script básico en Python que nos permita integrar al modelo de optimización, data de entrada proveniente de fuentes como un documento de Excel. Esto con el propósito de introducirnos en las bondades del modelamiento en lenguajes de programación.

Paso 1: Construir una base de datos en Microsoft Excel

En este caso, utilizaremos una hoja de cálculo haciendo uso de Microsoft Excel, en su extensión predeterminada xlsx, desde la cual, construiremos una base de datos que consignará toda la información de entrada relacionada con el modelo. Un consejo práctico, es que este archivo se guarde dentro del mismo directorio en el que se encuentra el modelo desarrollado en Python.

Se puede apreciar la forma en la cual hemos consignado la información, desde luego, respetando el orden de los datos, ya que, tal como lo mencionamos, es muy importante, ya que de ello depende la asociación de cada arco con su distancia. La anterior información la hemos consignado en la Hoja 1 del archivo, ya que en la Hoja 2 consignaremos la información relacionada con el suministros (con el objetivo práctico de mostrar cómo se importan datos desde hojas específicas), de esta manera:

Del mismo modo, el orden de los suministros es muy importante, razón por la cual hemos construido una columna denominada nodos que puede servir como guía para consignar la información de los suministros de forma ordenada.

Es de vital importancia, nombrar cada columna y tener claridad sobre ello, desaconsejamos el uso de caracteres especiales y sugerimos utilizar nombres cortos relacionados con la información contenida.

Posterior a consignar la información, podemos guardar el documento, en este caso lo hemos nombrado: data_flujo. Este dato es importante, ya que lo utilizaremos desde el script.

Paso 2: Importar la librería Pandas

En caso de requerir la instalación de la librería, tan solo debes escribir el siguiente comando en el símbolo del sistema:

pip install pandas

Esta paquete nos proporcionará la posibilidad de importar y trabajar con datos de fuentes como Microsoft Excel. El siguiente fragmento de código se adicionará al script e importará la librería:

# Importar la librería de Google OR-Tools
# Importar la librería de Pandas
from __future__ import print_function
from ortools.graph import pywrapgraph
import pandas as pd

Una vez que importemos la librería, podemos trabajar con sus funciones.

Paso 3: Importar datos desde Microsoft Excel

El desarrollo para importar la información desde Excel debe estar correctamente ordenada (correspondencia entre filas). Por ejemplo:

La anterior fila representa el arco entre el nodo 0 y el nodo 1 cuya capacidad es de 1 y de dimensión (distancia) 4.

En el caso de los suministros, debe considerarse el orden la columna en Excel. Por ejemplo:

En este caso, el nodo 0 será de oferta, es decir, desde ahí se crea flujo; el nodo 8 será de demanda, es decir, en este nodo se consume (sumidero). El nodo 4 será un nodo de tránsito (no crea inicia flujo ni lo consume), solo es un nodo de paso.

El siguiente fragmento de código importará la data que se encuentra consignada en el documento de Excel:

def create_data():

    excel = pd.read_excel('data_flujo.xlsx')
    excel_1 = pd.read_excel('data_flujo.xlsx', sheet_name=1)

    data = {}

    data['fuentes'] = excel['fuentes'].tolist() 
    data['destinos'] = excel['destinos'].tolist() 
    data['capacidad'] = excel['capacidad'].tolist() 
    data['distancias'] = excel['distancia'].tolist() 
    data['suministro'] = excel_1['suministros'].tolist() 

    return data 

Los datos de entrada del modelo los trataremos dentro de una función create_data, desde ahí utilizaremos algunas funciones de la librería Pandas (pd) para disponer correctamente de la información contenida en el documento de Excel. Veamos cómo:

excel = pd.read_excel(‘data_flujo.xlsx’)

En este caso, creamos la variable excel y dentro de ella utilizamos la función read_excel la cual permite leer el documento de Excel (en nuestro caso data_flujo.xlsx), e importarlo (en la variable excel) en formato dataframe (conjunto de columnas).

También creamos la variable excel_1 y dentro de ella utilizamos la función read_excel la cual permite leer el documento de Excel (en nuestro caso data_flujo.xlsx), e importarlo (en la variable excel). En este caso adicionamos el argumento sheet_name, el cual nos permite dentro del documento buscar la información en una hoja específica. Las hojas de Excel, en el caso de Python, se denominan desde el índice 0. Es decir que en nuestro caso, al expresar sheet_name=1 indicamos que lea la Hoja 2 del documento.

Creamos el directorio data, temporalmente vacío, en el se consignarán posteriormente cada lista de datos junto a su nombre (índice).

Ahora detallaremos cómo creamos cada listado de datos:

data[‘fuentes’] = excel[‘fuentes’].tolist()

En este caso data[‘fuentes’] indica que crearemos el índice ‘fuentes’ dentro del directorio data (que se encontraba vacío). excel[‘fuentes’] indica que dentro del dataframe Excel, queremos obtener la columna ‘fuentes’. Y la función tolist() convertirá esta columna en una lista (formato list). En defintiva, dentro de data[‘fuentes’] tendremos el listado de fuentes obtenido desde Excel.

Este mismo procedimiento lo repetimos para los datos restantes. Al finalizar, dentro del directorio data quedará contenida toda la información de entrada del modelo. Como la función create_data retorna la variable data, esto quiere decir, que toda la información de entrada quedará contenida dentro de la función create_data, esto permitirá su uso posterior.

Paso 4: Invocar la data del modelo en el main

Para utilizar los listados o inputs obtenidos desde Excel, necesitamos invocar la función «create_data» esta retornará el directorio con todos los datos.

Recomendamos utilizar el mismo nombre «data» para crear el directorio dentro de esta función:

data = create_data()

Ahora el «data» de esta función (main), contiene el directorio de la función «create_data«. Ya podemos usar los listados.

Quiere decir esto, que para acceder específicamente al listado que contiene los destinos, por ejemplo, es necesario invocar a data[‘destinos’].

Básicamente, estas son las modificaciones que deben realizarse sobre el modelo inicialmente desarrollado. De esta forma quedará nuestro código completo, el cual importará la data de entrada desde un archivo de Excel:

# """From Salazar, ingenieriaindustrialonline.com - Algoritmo de la ruta más corta"""

from __future__ import print_function
from ortools.graph import pywrapgraph #Librería de Google Or Tools
import pandas as pd #Librería pandas para obtener data desde Excel

"""MinCostFlow adaptado a la ruta más corta - interfaz de ejemplo."""

#Este desarrollo requiere que la información extraida desde Excel esté ordenada
#de acuerdo a sus filas. Por ejemplo:

#fila     fuentes   destinos    capacidad   distancia
# 1          0          1           1           4

#Esta fila representa el arco de capacidad 1 y distancia 4 que conecta el nodo fuente 0
#al nodo destino 1

#En el caso de los suministros, debe considerarse el orden de la columna de Excel. Por ejemplo:

#fila      nodos   suministros
# 1          0          1
# 5          4          0
# 9          8         -1

#En este caso, el nodo 0 será de oferta (desde ahí se crea flujo) y el nodo 8 será de demanda (ahí se consume).
#El nodo 4 será un nodo de tránsito (no crea flujo y no consume), solo es un nodo de paso.


#Creamos la data del modelo (La extraemos desde Excel)
def create_data():

    #La variable "excel" traerá la información contenida en el archivo "data_flujo.xlsx" (crea un dataframe organizado en columnas)
    excel = pd.read_excel('data_flujo.xlsx')
    excel_1 = pd.read_excel('data_flujo.xlsx', sheet_name=1) #Función que permite leer una hoja en específico (hoja 2 de Excel - Inicia desde 0)

    data = {} #Crea un directorio llamado data, en él agregaremos cada lista de datos junto con su nombre (índice)

    #La información contenida en Excel viene dada en un dataframe con todos los datos en columnas.
    #A continuación, extraeremos cada columna en específico, desde el dataframe (todas las columnas) > series (columna en específico)
    #Luego, el "tolist" convertirá cada serie en una lista. Esa lista se guardará en el directorio "data" y se etiqueta con el índice correspondiente

    data['fuentes'] = excel['fuentes'].tolist() #Columna en Excel = 'fuentes' > lista en el directorio "data" con la etiqueta (índice) "fuentes"
    data['destinos'] = excel['destinos'].tolist() #Columna en Excel = 'destinos' > lista en el directorio "data" con la etiqueta (índice) "destinos"
    data['capacidad'] = excel['capacidad'].tolist() #Columna en Excel = 'capacidad' > lista en el directorio "data" con la etiqueta (índice) "capacidad"
    data['distancias'] = excel['distancia'].tolist() #Columna en Excel = 'distancia' > lista en el directorio "data" con la etiqueta (índice) "distancia"
    data['suministro'] = excel_1['suministros'].tolist() #Columna en Excel = 'suministro' > lista en el directorio "data" con la etiqueta (índice) "suministro"

    #Quiere decir esto, que para acceder específicamente al listado que contiene los destinos, es necesario invocar a data['destinos'].

    return data #En "create_data" quedará contenido el directorio "data" el cuál contiene todas las listas con la información del modelo.


def main():

  #Para utilizar los listados o inputs obtenidos desde Excel, necesitamos invocar la función "create_data" esta retornará el directorio con todos los datos.
  #Recomendamos utilizar el mismo nombre "data" para crear el directorio dentro de esta función:

  data = create_data() #Ahora el "data" de esta función, contiene el directorio de la función "create_data". Ya podemos usar los listados.

  # Crea una instancia para el solucionador
  min_cost_flow = pywrapgraph.SimpleMinCostFlow()

  # Define cada arco del problema
  for i in range(0, len(data['fuentes'])):
    min_cost_flow.AddArcWithCapacityAndUnitCost(data['fuentes'][i], data['destinos'][i],
                                                data['capacidad'][i], data['distancias'][i])

  # Define los suministros para cada nodo.
  for i in range(0, len(data['suministro'])):
    min_cost_flow.SetNodeSupply(i, data['suministro'][i])


  # Encuentra el costo mínimo entre el nodo 0 y el nodo 8
  if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:
    print('Distancia mínima:', min_cost_flow.OptimalCost())
    print('')
    print('  Arco    Flujo / Capacidad  Distancia')
    for i in range(min_cost_flow.NumArcs()):
      cost = min_cost_flow.Flow(i) * min_cost_flow.UnitCost(i)
      print('%1s -> %1s    %3s   / %3s       %3s' % (
          min_cost_flow.Tail(i),
          min_cost_flow.Head(i),
          min_cost_flow.Flow(i),
          min_cost_flow.Capacity(i),
          cost))
  else:
    print('Hubo un problema con la entrada de flujo de distancia mínima.')

if __name__ == '__main__':
  main()

Ejecutamos el modelo:

De esta manera hemos logrado integrar una base de datos que se encuentra en un archivo de Excel, el cual podemos modificar en cualquier momento con suma facilidad; un modelo de optimización flexible basado en el algoritmo de flujos de costo mínimo y un solucionador potente. Así entonces, podemos con suma eficiencia, modelar problemas relacionados con el Algoritmo de la Ruta más corta.

En próximos artículos abordaremos algunos scripts básicos en Python que nos permitan exportar los resultados del solucionador en algún formato específico, y de acuerdo a una estructura definida.

La entrada Problema de la ruta más corta en Google OR-Tools se publicó primero en Ingenieria Industrial Online.

Variables y consideraciones

A la hora de elaborar un plan agregado se debe tener en cuenta que existen una serie de consideraciones que rigen la estrategia, ya sea por el horizonte de tiempo, por el criterio de las decisiones o por las restricciones que delimitan el sistema.

A continuación detallaremos estas consideraciones:

Horizonte de tiempo

Básicamente, la planeación agregada considera un horizonte de tiempo de corto y medio plazo, es decir que suele manejar un periodo entre 6 y 18 meses de planificación.

Criterios de decisión

El principal objetivo de la planeación agregada es aumentar la productividad, de manera que debe acercar a la organización a su meta económica. En este orden de ideas, la búsqueda de la maximización del beneficio se alinea con los objetivos del plan agregado, entendiéndose como la diferencia entre los ingresos y los gastos operativos, por ende es válido considerar la minimización de los costos totales (mientras no se afecten los ingresos) como criterio de decisión de la planeación agregada.

Teniendo en cuenta lo anterior, es necesario evaluar con espíritu crítico y perspectiva sistémica, todas las relaciones entre los recursos disponibles para llevar a cabo el plan y sus implicaciones en los costos totales. De manera que pueden identificarse los costos asociados a los siguientes factores:

Restricciones

Todos los sistemas objetos de planeación agregada se encuentran sujetos a restricciones y de diversos tipos, tales como:

Modelos de programación lineal en planeación agregada

Existen diversos métodos empleados en la creación de un plan agregado, entre los que se destacan la programación lineal, reglas de decisión por búsqueda, programación por objetivos, programación dinámica, o métodos heurísticos (ensayo y error).

La programación lineal por sus características innatas de modelación libre, se constituye como una herramienta poderosa de resolución de planes agregados, de manera que puede considerar tantas restricciones como la realidad del sistema lo presenten, al mismo tiempo que se enfoca en soluciones óptimas, a diferencia de los métodos heurísticos de comparación de alternativas.

A continuación, se detallará un modelo de programación lineal mixta propuesto por el autor, que considerará la mayor parte de los criterios de decisión contemplados en los métodos heurísticos de comparación de alternativas, en búsqueda de una solución óptima.

Modelo de programación lineal mixta aplicado a Planeación Agregada

En el modelo propuesto las decisiones se toman de acuerdo con una fuerza de trabajo flexible considerando tiempo extraordinario de trabajo y una tasa de producción que contempla un factor de eficiencia reducida para operarios nuevos en el periodo de contratación, simulando el impacto de la curva de aprendizaje.

Los costos que afectan la función objetivo se expresan en «costos por unidades agregadas» y «costos por operario», e incluye los componentes de:

Además, los costos asociados al tiempo normal y extraordinario relacionados con los operarios nuevos también contemplan el factor de eficiencia reducida por periodo.

Datos de entrada requeridos

El modelo que hemos preparado requiere de los siguientes datos de entrada:

m = Número de periodos del plan

días = Número de días de cada periodo del plan

requerimientos = Los requerimientos estimados de cada periodo del plan (unidades)

Jornada laboral = Jornada laboral en términos de horas / día

Tiempo unitario = Tiempo empleado en producir una unidad (horas / trabajador / unidad)

Eficiencia = En este modelo consideramos esta variable como factor de eficiencia de los operarios nuevos (curva de aprendizaje) – Solo la consideramos durante el primer periodo de producción del operario

Horas extras máx. = Cantidad máxima de horas extras que puede emplear un operario por periodo

Unidades subcontratadas máx. = Cantidad máxima de unidades que se pueden subcontratar por periodo

Inventario Inicial = Inventario Inicial dado en unidades

Costo normal = Costo de tiempo normal ($ / hora)

Costo extra = Costo de tiempo extra ($ / hora)

Costo de inventario = Costo de tener unidades en inventario ($ / unidad / periodo)

Costo de subcontratar = Costo de tercerizar la fabricación de unidades ($ / unidad)

Costo de contratar = Costo de contratar un operario ($ / operario)

Costo de despedir = Costo de despedir un operario ($ / operario)

Operarios = Número inicial de operarios

La siguiente formulación ha sido evaluada y validada en diversos programas solucionadores, como Solver, QM, WinQSB y Google Or-Tools.

Variables de decisión

x_i = Cantidad de unidades a producir en tiempo normal por operarios antiguos en el periodo i

xn_i = Cantidad de unidades a producir en tiempo normal por operarios nuevos en el periodo i

xz_i = Cantidad de unidades a producir en tiempo extra por operarios antiguos en el periodo i

xnz_i = Cantidad de unidades a producir en tiempo extra por operarios nuevos en el periodo i

c_i = Número de operarios a contratar en el periodo i

d_i = Número de operarios a despedir en el periodo i

oi_i = Número de operarios totales al inicio del periodo i

of_i = Número de operarios totales al final del periodo i

sub_i = Número de unidades a subcontratar en el periodo i

_invi = Número de unidades en inventario al final del periodo i

Variables de cálculos intermedios

P_i = Cantidad de unidades que puede producir en tiempo normal un operario antiguo en el periodo i

Pn_i = Cantidad de unidades que puede producir en tiempo normal un operario nuevo en el periodo i

H_i = Cantidad máxima de unidades que puede producir en tiempo extra un operario antiguo en el periodo i

Hc_i = Cantidad máxima de unidades que puede producir en tiempo extra un operario nuevo en el periodo i

Formulación de cálculos intermedios

P_i = (jornada laboral / tiempo unitario) * días del periodo i

Pn_i = P_i * Eficiencia

H_i = Horas extras máx. del periodo i / tiempo unitario

Hc_i = H_i * Eficiencia

Variables y entradas financieras

Costo unitario normal = Costo normal * Tiempo unitario

Costo unitario normal (operarios nuevos) = Costo normal * (Tiempo unitario / Eficiencia)

Costo unitario extra = Costo extra * Tiempo unitario

Costo unitario extra (operarios nuevos) = Costo extra * (Tiempo unitario / Eficiencia)

Restricciones de tiempo normal (Operarios antiguos)

( P_i * oi_i ) – x_i >= 0

Restricciones de tiempo normal (Operarios nuevos)

( Pn_i * c_i ) – xn_i >= 0

Restricciones de balance de operarios

Esta restricción define que los operarios al final de un periodo i = operarios inicial periodo i + 1

Para todos los i >= 1:

oi_i – of_i-1 = 0

Restricciones de balance para la contratación de operarios

Para todos los i >= 1:

of_i – oi_i – c_i + d_i = 0

Restricciones de cantidad inicial de operarios

Esta restricción nos indica que la cantidad inicial de operarios, es decir oi en periodo 0, es equivalente al dato de entrada operarios (El cual nos indica la cantidad inicial de operarios del problema). Esta restricción parece demasiado lógica, sin embargo es vital considerarla de acuerdo a los solucionadores que utilicemos.

oi₀ – operarios = 0

Restricciones de balance de operarios en el periodo 0 (periodo inicial)

of₀ – oi₀ – c₀ + d₀ = 0

Restricciones de límites de horas extras (operarios antiguos)

xz_i – ( H_i  * oi_i ) <= 0

Restricciones de límites de horas extras (operarios nuevos)

xnz_i – ( Hc_i  * c_i ) <= 0

Restricciones de límites de unidades a subcontratar

_subi – unidades subcontratadas máx. en el periodo i <= 0

Restricciones de balance de inventarios (periodo 1 en adelante)

Para todos los i >= 1:

Restricciones de balance de inventarios (periodo 0)

Restricciones de satisfacción de requerimientos (periodo 1 en adelante)

Para todos los i >= 1

x_i  + xn_i + xz_i  + xnz_i + sub_i  + inv_{i – 1} – requerimientos del periodo i >= 0

Restricciones de satisfacción de requerimientos (periodo 0)

x₀  + xn₀ + xz₀  + xnz₀ + sub₀  + inventario inicial – requerimientos del periodo 0 >= 0

Restricciones de no negatividad

Todas las variables pertenecen a los números reales enteros y sus valores deberán ser mayores o iguales a cero.

Función objetivo

Zmin = (costo unitario normal * x_i ) + (costo unitario normal de operarios nuevos * xn_i ) + (costo unitario extra * xz_i ) + (costo unitario extra operarios nuevos * xnz_i ) + (costo de subcontratar * sub_i ) + (costo de contratar * c_i ) + (costo de despedir * d_i ) + (costo de inventarios * inv_i )

La aplicación del anterior modelo arrojará la solución óptima por medio del algoritmo «branch and bound».

Caso de estudio: Aplicación de programación lineal en planeación agregada

Una compañía desea determinar su plan agregado de producción para los próximos 6 meses. Una vez utilizado el modelo de pronóstico más adecuado se establece el siguiente tabulado de requerimientos (no se cuenta con inventario inicial, y no se requiere de inventarios de seguridad).

Información relacionada con el negocio:

Jornada laboral: 8 horas / trabajador / día

Costo de contratar: $ 350 / trabajador

Costo de despedir: $ 420 / trabajador

Costo de tiempo normal (mano de obra): $ 6 / hora

Costo de tiempo extra (mano de obra): $8 / hora

Costo de mantenimiento de inventarios: $ 3 /unidad/ mes

Costo de subcontratar: $ 50 / unidad

Tiempo de procesamiento: 5 horas / trabajador / unidad

Jornada laboral: 8 horas / día

Número inicial de trabajadores: 20

Eficiencia de un trabajador nuevo el primer periodo: 90%

Cantidad máxima de horas extras por operario por mes: 8 horas/trabajador/mes

Capacidad máxima de suministro de unidades de subcontratación: 200 unidades/mes

Unidades: Toneladas.

---

Ya en la introducción del modelo hemos descrito la definición de las variables, la formulación de los cálculos intermedios, así mismo la formulación de las restricciones. Estas pueden utilizarse básicamente en cualquier solucionador.

En este caso vamos a utilizar un solucionador de programación basada en restricciones: Google OR-Tools. Para eso, vamos a programar nuestro modelo utilizando Python. No se preocupe si no cuenta con este programa, la idea es introducirnos de a poco en estas nuevas soluciones, por lo tanto utilizaremos un entorno virtual que podrás ejecutar sin la necesidad de realizar ninguna instalación.

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

Paso 1: Instalar las librerías de Google Or Tools

Este paso debe realizarse solo si vamos a utilizar el cuaderno de Colaboratory:

!pip install ortools

Paso 2: Importar las librerías necesarias y declarar el solucionador

En este caso, solo importaremos la librería correspondiente al módulo de programación lineal de Google Or-Tools. Además, utilizaremos el solucionador SCIP (Solving Constraint Integer Programs), un solucionador de código abierto disponible que permite resolver problemas lineales mixtos (Google OR-Tools posee múltiples solucionadores):

from ortools.linear_solver import pywraplp

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

Paso 3: Datos de entrada

De acuerdo a los datos que nos plantea el problema, registramos las entradas del modelo:

#DATOS DE ENTRADA

periodos = [0, 1, 2, 3, 4, 5] #Periodos del plan, empezando desde el periodo 0
demanda = [2500, 1500, 3000, 1000, 2500, 2200] #Requerimintos de cada periodo
dias = [22, 19, 21, 21, 22, 20] #Días laborales de cada periodo
jornada_laboral = 8 #horas / trabajador / día
tiempo_unitario = 5 #horas / unidad
Eficiencia = 0.9 #Eficiencia de un trabajador nuevo periodo 1
horas_extras_max = [8, 8, 8, 8, 8, 8] #Cantidad máxima de horas extras por periodo
unidades_sub_max = [200, 200, 200, 200, 200, 200] #Cantidad máxima de unidades que se pueden subcontratar en el periodo i
inv_inicial = 0 #Unidades
costo_normal = 6 #Unidades monetarias / hora
costo_extra = 8 #Unidades monetarias / hora
costo_inventario = 3 #Unidades monetarias / periodo
costo_sub = 50 #Unidades monetarias / unidad
costo_contratar = 350 #Unidades monetarias / trabajador
costo_despedir = 420 #Unidades monetarias / trabajador
operarios = 20 #Número inicial de trabajadores

Paso 4: Definir y formular los cálculos intermedios

De acuerdo a la formulación que ya mostramos de nuestro modelo, se definirán aquellos cálculos intermedios necesarios. Recordemos la formulación que teníamos definida:

P_i = (jornada laboral / tiempo unitario) * días del periodo i

Pn_i = P_i * Eficiencia

H_i = Horas extras máx. del periodo i / tiempo unitario

Hc_i = H_i * Eficiencia

Si realizamos los cálculos de forma manual, podemos completar una tabla como la siguiente:

Veamos por ejemplo, el periodo 0 (periodo inicial).

P₀ (mes 1) = (8 / 5) * 22

P₀ (mes 1) = 35,20

Ahora veamos cómo podemos programar este cálculo en nuestro modelo (mediante un ciclo):

P= [] #Cantidad de unidades que puede producir un operario en el periodo i
for i in range(len(periodos)):
    P.append((jornada_laboral / tiempo_unitario) * dias[i])

De esta forma efectuamos el cálculo para cada período. Veamos lo que pasaría imprimimos la variable P:

Podemos corroborar cómo obtenemos los mismos resultados que se encuentran consignados en el tabulado. Ahora completaremos los cálculos intermedios restantes:

Pn= []#Cantidad de unidades que puede producir un operario nuevo en el periodo i
for i in range(len(periodos)):
    Pn.append(P[i] * Eficiencia)
    
H= []#Cantidad máxima de unidades que puede producir un operario en el periodo i con horas extras
for i in range(len(periodos)):
    H.append(horas_extras_max[i] / tiempo_unitario)
    
Hc= []#Cantidad máxima de unidades que puede producir un operario en el periodo i con horas extras
for i in range(len(periodos)):
    Hc.append(H[i] * Eficiencia)

Paso 5: Definir las variables de decisión

En este paso definiremos cada variable de decisión del modelo, definiremos también su naturaleza y su rango de valores: entera, mayor o iguala cero (desde 0 hasta infinito).

#Variables de decisión

x= {} #Unidades a producir en el periodo i
for i in range(len(periodos)):
    x[i] = solver.IntVar(0, solver.infinity(), '')
    
xn= {} #Unidades a producir por operarios nuevos en el periodo i
for i in range(len(periodos)):
    xn[i] = solver.IntVar(0, solver.infinity(), '')
    
xz= {} #Unidades a producir en tiempo extra en el periodo i
for i in range(len(periodos)):
    xz[i] = solver.IntVar(0, solver.infinity(), '')
    
xnz= {} #Unidades a producir en tiempo extra por operarios nuevos en el periodo i
for i in range(len(periodos)):
    xnz[i] = solver.IntVar(0, solver.infinity(), '')
    
c= {} #Operarios a contratar en el período i
for i in range(len(periodos)):
    c[i] = solver.IntVar(0, solver.infinity(), '')

d= {} #Operarios a despedir en el período i
for i in range(len(periodos)):
    d[i] = solver.IntVar(0, solver.infinity(), '')
    
sub= {} #Unidades a subcontratar en el periodo i
for i in range(len(periodos)):
    sub[i] = solver.IntVar(0, solver.infinity(), '') 
    
inv= {} #Unidades en inventario al final del periodo i
for i in range(len(periodos)):
    inv[i] = solver.IntVar(0, solver.infinity(), '') 
    
oi= {} #Número de operarios totales al inicio del periodo i
for i in range(len(periodos)):
    oi[i] = solver.IntVar(0, solver.infinity(), '') 
    
of= {} #Número de operarios totales al final del periodo i
for i in range(len(periodos)):
    of[i] = solver.IntVar(0, solver.infinity(), '') 

En el código anterior, y ya que cada variable debe definirse para cada periodo del plan agregado, utilizamos ciclos para su definición. Este ciclo tiene un rango determinado por el número de periodos, de esta manera, ya que tenemos 6 periodos, por ejemplo, en la definición de la variable Xi, tendremos las siguientes variables definidas: x₀, x₁, x₂, x₃, x₄, x₅ . Así mismo sucede con las variables restantes.

Desde luego, existe la posibilidad de definir cada una de las variables de forma individual, sin embargo el proceso sería algo tedioso, y sería algo así:

x[0] = solver.IntVar(0, solver.infinity(), »)

x[1] = solver.IntVar(0, solver.infinity(), »)

x[2] = solver.IntVar(0, solver.infinity(), »)

x[3] = solver.IntVar(0, solver.infinity(), »)

x[4] = solver.IntVar(0, solver.infinity(), »)

x[5] = solver.IntVar(0, solver.infinity(), »)

Por esta razón utilizamos ciclos para tal efecto.

Paso 6: Formulación de variables de costo

#Formulación de variables financieras (Costos)
costo_unitario_normal = costo_normal * tiempo_unitario
costo_unitario_normal_nuevo = costo_normal * (tiempo_unitario / Eficiencia) 
costo_unitario_extra = costo_extra * tiempo_unitario
costo_unitario_extra_nuevo = costo_extra * (tiempo_unitario / Eficiencia) 

Paso 7: Restricciones del modelo

Utilizando la misma metodología de ciclos para recorrer los periodos del plan, formulamos nuestras restricciones. Estas restricciones son exactamente las mismas que formulamos de manera algebraica en el planteamiento general de nuestro modelo.

#RESTRICCIONES DEL MODELO

# Restricciones de tiempo normal (Producción normal)
for i in range(len(periodos)):
    solver.Add(((P[i] * oi[i]) - x[i]) >= 0)

# Restricciones de tiempo normal (Producción normaml - operarios nuevos)
for i in range(len(periodos)):
    solver.Add(((Pn[i] * c[i]) - xn[i]) >= 0)
    
# Restricciones de balance (operarios al final de un periodo i = operarios inicial periodo i + 1)
for i in range(1, len(periodos)):
    solver.Add(oi[i] - of[i-1] == 0)
    
# Restricciones de balance para la contratación de operarios (periodo i en adelante)
for i in range(1, len(periodos)):
    solver.Add(of[i] - oi[i] - c[i] + d[i] == 0)
    
# Restricción de cantidad inicial de operarios
solver.Add(oi[0] - operarios == 0)
    
# Restricciones de balance de operarios periodo 0
solver.Add(of[0] - oi[0] - c[0] + d[0] == 0)
    
# Restricciones límite de horas extras operarios antiguos
for i in range(len(periodos)):
    solver.Add(xz[i] -(H[i] * oi[i]) <= 0)
    
# Restricciones límite de horas extras operarios nuevos
for i in range(len(periodos)):
    solver.Add(xnz[i] -(Hc[i] * c[i]) <= 0)
    
# Restricciones límite de unidades a subcontratar
for i in range(len(periodos)):
    solver.Add(sub[i] - unidades_sub_max[i] <= 0) 

# Restricciones límite de balance de inventarios periodo 1 en adelante 
for i in range(1, len(periodos)): 
    solver.Add(inv[i-1] + x[i] + xn[i] + xz[i] + xnz[i] + sub[i] - demanda[i] - inv[i] == 0) 

# Restricciones límite de balance de inventarios periodo 0 
solver.Add(inv_inicial + x[0] + xn[0] + xz[0] + xnz[0] + sub[0] - demanda[0] - inv[0] == 0) 

# Restricciones de satisfacción de demanda periodo 1 en adelante 
for i in range(1, len(periodos)): 
    solver.Add(x[i] + xn[i] + xz[i] + xnz[i] + sub[i] + inv[i-1] - demanda[i] >= 0)
    
# Restricciones límite de balance de inventarios periodo 0
solver.Add(x[0] + xn[0] + xz[0] + xnz[0] + sub[0] + inv_inicial - demanda[i] >= 0)

Paso 8: Definir la función objetivo

#FUNCIÓN OBJETIVO MINIMIZAR
objective_terms = []
for i in range(len(periodos)):
    objective_terms.append((costo_unitario_normal * x[i]) + (costo_unitario_normal_nuevo * xn[i]) + (costo_unitario_extra * xz[i]) + (costo_unitario_extra_nuevo * xnz[i]) + (costo_sub * sub[i]) + (costo_contratar * c[i]) + (costo_despedir * d[i]) + (costo_inventario * inv[i]))
solver.Minimize(solver.Sum(objective_terms))  

Paso 9: Invocar al solucionador

A continuación daremos la orden al programa de resolver el modelo.

#Invocar al solucionador
status = solver.Solve()

Paso 10: Configurar las salidas del modelo

Este paso lo verán quizá confuso; y la verdad no lo es tanto. Toda vez que el modelo está resuelto, podemos configurar la salida que queramos en cualquier momento; eso sí, hemos desarrollado unas líneas de código que pueden resultar extensas, con el fin de organizar los datos de salida. Por ejemplo, hemos definido encabezados para los datos, y otras cuestiones de forma.

Si usted desea, por ejemplo, tan solo conocer el valor total del plan agregado, puede introducir las siguientes líneas:

print('\nValor total del plan (FO) =', solver.Objective().Value())

Al ejecutar esta línea tendremos el siguiente resultado:

Las siguientes líneas nos proporcionarán la información relevante de forma organizada:

if status == pywraplp.Solver.OPTIMAL:
    print('\nSOLUCIÓN: ')        
    print('\nPLAN DE PRODUCCIÓN \n')
    print('|{:^20}|{:^20}|{:^20}|{:^20}|{:^20}|{:^20}|'.format(
      'Período',
      'Producción (TN)',
      'TN (Op. Nuevos)',
      'Producción (HE)',
      'HE (Op. Nuevos)',
      'Uni. Subcon'))
    
    for i in range(len(periodos)):
        print('|{:^20}|{:^20}|{:^20}|{:^20}|{:^20}|{:^20}|'.format(
          i,
          x[i].solution_value(),
          xn[i].solution_value(),
          xz[i].solution_value(),
          xnz[i].solution_value(),
          sub[i].solution_value()))
    print('\nProduccción (TN): Cantidad de unidades a producir en tiempo normal')
    print('TN (Op. Nuevos): Cantidad de unidades a producir en tiempo normal con operarios nuevos')
    print('Producción (HE): Cantidad de unidades a producir en tiempo extra')
    print('HE (Op. Nuevos): Cantidad de unidades a producir en tiempo extra con operarios nuevos')
    print('Uni. Subcon: Cantidad de unidades a subcontratar')
    print('\nCOSTOS \n')
    print('|{:^20}|{:^20}|'.format(
          'Período',
          'Costo'))  
    costo = []
    for i in range(len(periodos)):
        costo.append((costo_unitario_normal * x[i].solution_value()) + (costo_unitario_normal_nuevo * xn[i].solution_value()) + (costo_unitario_extra * xz[i].solution_value()) + (costo_unitario_extra_nuevo * xnz[i].solution_value()) + (costo_sub * sub[i].solution_value()) + (costo_contratar * c[i].solution_value()) + (costo_despedir * d[i].solution_value()) + (costo_inventario * inv[i].solution_value()))
        print('|{:^20}|{:^20.2f}|'.format(
          i,
          costo[i]))
    print('\nValor total del plan (FO) =', solver.Objective().Value())
    print('Costo unitario del tiempo normal = {0} unidades monetarias / h'.format(costo_unitario_normal))
    print('Costo unitario del tiempo normal (Operarios nuevos)= {0:.2f} unidades monetarias / h'.format(costo_unitario_normal_nuevo))
    print('Costo unitario del tiempo extra= {0} unidades monetarias / h'.format(costo_unitario_extra))
    print('Costo unitario del tiempo extra (Operarios nuevos)= {0:.2f} unidades monetarias / h'.format(costo_unitario_extra_nuevo))
    print('\nINVENTARIOS \n')
    print('|{:^20}|{:^20}|'.format(
          'Período', 
          'Inv. final'))  
    for i in range(len(periodos)):    
        print('|{:^20}|{:^20}|'.format(
          i,
          inv[i].solution_value()))
    print('\nFUERZA LABORAL (OPERARIOS)\n')
    print('|{:^20}|{:^20}|{:^20}|{:^20}|{:^20}|'.format(
          'Período', 
          'Cantidad inicial',
          'Contrataciones',
          'Despidos',
          'Cantidad final'))  
    for i in range(len(periodos)):    
        print('|{:^20}|{:^20}|{:^20}|{:^20}|{:^20}|'.format(
          i,
          oi[i].solution_value(),
          c[i].solution_value(),
          d[i].solution_value(),
          of[i].solution_value()))
   
    vector_i=[]
    vector_x=[]
    vector_xn=[]
    vector_xz=[]
    vector_xnz=[]
    vector_sub=[]    
    
    for i in range (len(periodos)):
        vector_i.append(i)
        vector_x.append(x[i].solution_value())
        vector_xn.append(xn[i].solution_value())
        vector_xz.append(xz[i].solution_value())
        vector_xnz.append(xnz[i].solution_value())
        vector_sub.append(sub[i].solution_value())    
    
    datos = {}
    
    datos['Periodo'] = vector_i
    datos['Producción (TN)'] = vector_x
    datos['TN (Op. Nuevos)'] = vector_xn
    datos['Producción (HE)'] = vector_xz
    datos['HE (Op. Nuevos)'] = vector_xnz
    datos['Uni. Subcon'] = vector_sub
      
else:
  if status == solver.FEASIBLE:
    print('Se encontró una solución potencialmente subóptima.')
  else:
    print('El problema no tiene solución óptima.')

Al ejecutar el modelo tendremos:

Puedes acceder y ejecutar el modelo desde Planeación Agregada mediante Programación Lineal.

El tiempo empleado por el solucionador es inferior a 1 segundo de procesamiento. Dada la potencia del solucionador Google Or Tools y la capacidad de procesamiento del entorno virtual.

El valor objetivo hallado es: 408074,33

Parte de la utilidad de este desarrollo es la posibilidad de integrarse con diversas fuentes de información. Puede, por ejemplo, tomar datos desde diversos archivos en entornos locales o externos. De igual forma puede exportar la información obtenida.

Utilizando este modelo y su formulación en Solver de Microsoft Excel

El mismo modelo que hemos desarrollado en Python ha sido formulado en Microsoft Excel para su resolución mediante Solver. De acuerdo a los parámetros genéricos de Solver, sin modificar límites de búsqueda, hemos obtenido una solución equivalente a: 410498, empleando aproximadamente 50 segundos para llegar a ella.

Podemos observar entonces que la solución obtenida mediante Google Or-Tools satisface mucho más el criterio de optimización, así mismo alcanza la solución en un tiempo mucho menor.

¿A qué puede deberse esa diferencia entre las soluciones obtenidas mediante ambos solucionadores? Principalmente a la tolerancia predeterminada de los solucionadores de Solver para las restricciones de variables enteras. Es posible incluso, en el cuadro de opciones de Solver configurar esta tolerancia como 0 para obtener mejores resultados. Lo hemos hecho y hemos alcanzado 419601. Sin embargo, el tiempo de búsqueda puede tardar minutos.

La entrada Planeación agregada mediante programación lineal se publicó primero en Ingenieria Industrial Online.