在 pyomo 的混合 integer 编程问题中设置复杂的约束

Question

在我的优化问题中，我必须将尽可能多的货车分配到其最佳路线，以在定义约束的情况下以最低成本（多目标问题）。 第一步，我必须分配尽可能多的货车（最大数量），优化的第二步是将其数量分配给最便宜的路线。 我有每个车站要分配的货车数量，我有每个到达站的容量。 为简单起见，我只有两个出发站，其中rem_type列表示该站的货车类型。 表df_vrp包含有关容量的信息，表df_unload包含有关我们必须分配给路线的每个出发站的货车数量的信息。我很清楚如何在约束条件下从一个站到另一个站的最大可能货车数量然后找到最便宜的路线。 但是，就我而言，我必须考虑分布式货车的比例，使得 2 型分布式货车的总和必须等于 1 型分布式货车总和的 1/3。所以我无法理解如何创建这样的约束是因为 1/3 可以通过多种方式完成（1 辆 2 型货车和 3 辆 1 型货车，3 辆 2 型货车和 9 辆 1 型货车等等）。

import pandas as pd
import numpy as np
from pyomo.environ import *

data = {'rem_type' : ['Type1', 'Type1', 'Type2', 'Type2', 'Type1', 'Type1', 'Type2', 'Type2'],
        'station_depart': ['A', 'A', 'A', 'A', 'F', 'F', 'F', 'F'],
        'station_arrive': ['B', 'C', 'B', 'C', 'B', 'C', 'B', 'C'],
        'cost': [100, 103, 111, 101, 105, 114, 95, 99]}

  
df_route = pd.DataFrame(data)

# unload
df_unload = pd.DataFrame({'rem_type' : ['Type1', 'Type2', 'Type1', 'Type2'], 
                          'station_depart' : ['A', 'A', 'F', 'F'],
                          'volume' : [5, 6, 4, 7]})

# repair
df_vrp = pd.DataFrame({'rem_type' : ['Type1', 'Type2'], 
                       'station_arrive' : ['B', 'C'],
                       'capacity' : [15, 30]})

# create routes
routes_unload = dict()   
routes_vrp = dict()    

# create model
model = ConcreteModel("OP")

# create multi objective function
model.Models = ObjectiveList()

# decision vars
model.x = Var([idx for idx in df_route.index], domain=NonNegativeIntegers)

# obj function to maximize the number of allocated wags to routes
model.Size = Objective(expr=sum([model.x[i] for i in model.x]), sense=maximize)

# obj function to minimize cost of those wags from the first solution
model.Cost = Objective(
    expr=sum([df_route.loc[idx, "cost"] * model.x[idx] for idx in df_route.index]),
    sense=minimize,
)

model.Size.activate()
model.Cost.deactivate()

# routes with indexes for creating constraints
for idx in tqdm(df_route.index):
    vrp = (df_route.loc[idx, "rem_type"], df_route.loc[idx, "station_arrive"])
    if vrp not in routes_vrp:
        routes_vrp[vrp] = list()
    routes_vrp[vrp].append(idx)

    t_unload = (df_route.loc[idx, "rem_type"], df_route.loc[idx, "station_depart"])
    if t_unload not in routes_unload:
        routes_unload[t_unload] = list()
    routes_unload[t_unload].append(idx)

# constraints on the arrive/repair station
model.vrp = ConstraintList()
for v in df_vrp.index:
    t = (df_vrp.loc[v, "rem_type"], df_vrp.loc[v, "station_arrive"])
    if t in routes_vrp:
        model.vrp.add(
            sum([model.x[idx] for idx in routes_vrp[t]]) <= df_vrp.loc[v, "capacity"]
        )

# constraints on the depart station (how many wagons we have for allocation)
model.unload = ConstraintList()
for u in df_unload.index:
    t = (df_unload.loc[u, "rem_type"], df_unload.loc[u, "station_depart"])
    if t in routes_unload:
        model.unload.add(
            sum([model.x[idx] for idx in routes_unload[t]]) <= df_unload.loc[u, "volume"]
        )

results = SolverFactory("glpk").solve(model)

results.write()

# the result from the first objective function as the constraint to the second one
model.fix_count = Constraint(expr=sum([model.x[i] for i in model.x]) == model.Size())

model.Size.deactivate()
model.Cost.activate()

results = SolverFactory("glpk").solve(model)

results.write()

# create df with results of allocation to the routes
vals = []
for i in tqdm(model.x):
    vals.append(model.x[i].value)
df_results = df_route.dropna(
    subset=["rem_type", "station_depart", "station_arrive", "cost"],
    how="all",
)

df_results["total"] = vals

Answer 1

这是一个完整的答案，基于您更新的代码。 我对此有点“怪胎”，但仔细考虑后，您帮助我解决了我一直在处理的另一个问题，所以我们是 GTG。

我认为您的基本代码的主要问题之一是您试图将pandas强制放入pyomo框中，这很快就会变得困难，代码变得非常混乱。 我建议尽快放弃pandas以获得清晰度和更干净地使用集合的能力，因为正如您之前所做的那样，您已经通过所有路由的枚举进行索引，并且您真的希望能够根据目的地、车辆类型等进行限制，如果不这样设置，很难做到这一点。

我还将所有参数带入 model。这是可选的，但我认为能够pprint()整个 model 或更干净的部分是一个很好的做法。

如果您有一组不完整的路由和类型对，则需要做更多的工作。 意思是，如果有些路线只承载一种类型的车辆，则您必须进行一些过滤或使用索引集等，但现在所有类型在所有路线上都是兼容的，所以这是可行的。

请注意，第二遍的结果翻转了一些结果以最小化成本，这是您的目标。

代码：

import pandas as pd  # <--- try to avoid this, unless needed to curate the data
# import numpy as np
from pyomo.environ import *

data = {'rem_type' : ['Type1', 'Type1', 'Type2', 'Type2', 'Type1', 'Type1', 'Type2', 'Type2'],
        'station_depart': ['A', 'A', 'A', 'A', 'F', 'F', 'F', 'F'],
        'station_arrive': ['B', 'C', 'B', 'C', 'B', 'C', 'B', 'C'],
        'cost': [100, 103, 111, 101, 105, 114, 95, 99]}
df_route = pd.DataFrame(data)

costs = df_route.set_index(['station_depart', 'station_arrive', 'rem_type']).to_dict()['cost']

# unload
df_unload = pd.DataFrame({'rem_type' : ['Type1', 'Type2', 'Type1', 'Type2'], 
                          'station_depart' : ['A', 'A', 'F', 'F'],
                          'volume' : [5, 6, 4, 7]})
demands = df_unload.set_index(['station_depart', 'rem_type']).to_dict()['volume']

# repair
df_vrp = pd.DataFrame({'rem_type' : ['Type1', 'Type2'], 
                       'station_arrive' : ['B', 'C'],
                       'capacity' : [15, 30]})
capacity = df_vrp.set_index(['station_arrive', 'rem_type']).to_dict()['capacity']

# find the set of available routes and others conveniences
routes = {(s, t) for (s, t, cost) in costs.keys()}
start_nodes = {k[0] for k in costs.keys()}
end_nodes = {k[1] for k in costs.keys()}
all_nodes = start_nodes | end_nodes

# Target Ratios   
ratios =    {('Type1', 'Type2') : (3, 1)
              # others
            }

# MODEL

# create model
model = ConcreteModel("OP")

# SETS
model.N = Set(initialize=sorted(all_nodes))
model.S = Set(within=model.N, initialize=sorted(start_nodes))       # the set of start nodes
model.T = Set(within=model.N, initialize=sorted(end_nodes))         # the set of terminations
model.R = Set(within=model.N * model.N, initialize=sorted(routes))  # the set of connections
model.V = Set(initialize=['Type1', 'Type2'])                        # vehicle types
model.ratio_pairs = Set(within=model.V * model.V, initialize=ratios.keys())

# PARAMS
model.cost         = Param(model.R, model.V, initialize=costs)
model.demand       = Param(model.S, model.V, initialize=demands, default=0)  # the demand to send from s of type v
model.capacity     = Param(model.T, model.V, initialize=capacity, default=0) # the capacity to accept at t type v
model.ratio_limits = Param(model.ratio_pairs, initialize=ratios, domain=Any)

# VARS
model.send = Var(model.R, model.V, domain=NonNegativeIntegers)  # send this number of vehicles of type v on route r

# OBJ1: Route as much as possible
model.obj1 = Objective(expr=sum_product(model.send), sense=maximize)

# CONSTRAINTS

@model.Constraint(model.S, model.V)
def demand_limit(model, s, v):
    return sum(model.send[r, v] for r in model.R if r[0] == s) <= model.demand[s, v]

@model.Constraint(model.T, model.V)
def capacity_limit(model, t, v):
    return sum(model.send[r, v] for r in model.R if r[1] == t) <= model.capacity[t, v]

# the ratio constraint...
@model.Constraint(model.ratio_pairs)
def ratio_limit(model, v1, v2):
    return sum(model.send[r, v1] for r in model.R) * model.ratio_limits[v1, v2][0] == \
           sum(model.send[r, v2] for r in model.R) * model.ratio_limits[v1, v2][1]


# solve first pass...
results = SolverFactory("glpk").solve(model)
results.write()
model.send.display()
model.ratio_limit.pprint()

# now, add a constraint to make sure we deliver at least as much as before and introduce a
# new cost objective

model.min_send = Constraint(expr=sum_product(model.send) >= value(model.obj1))

model.obj2 = Objective(expr=sum_product(model.cost, model.send), sense=minimize)

model.obj1.deactivate()

results = SolverFactory("glpk").solve(model)

results.write()
model.send.display()

OUTPUT：

# ==========================================================
# = Solver Results                                         =
# ==========================================================
# ----------------------------------------------------------
#   Problem Information
# ----------------------------------------------------------
Problem: 
- Name: unknown
  Lower bound: 16.0
  Upper bound: 16.0
  Number of objectives: 1
  Number of constraints: 10
  Number of variables: 9
  Number of nonzeros: 25
  Sense: maximize
# ----------------------------------------------------------
#   Solver Information
# ----------------------------------------------------------
Solver: 
- Status: ok
  Termination condition: optimal
  Statistics: 
    Branch and bound: 
      Number of bounded subproblems: 9
      Number of created subproblems: 9
  Error rc: 0
  Time: 0.006043910980224609
# ----------------------------------------------------------
#   Solution Information
# ----------------------------------------------------------
Solution: 
- number of solutions: 0
  number of solutions displayed: 0
send : Size=8, Index=send_index
    Key                 : Lower : Value : Upper : Fixed : Stale : Domain
    ('A', 'B', 'Type1') :     0 :   0.0 :  None : False : False : NonNegativeIntegers
    ('A', 'B', 'Type2') :     0 :   0.0 :  None : False : False : NonNegativeIntegers
    ('A', 'C', 'Type1') :     0 :   0.0 :  None : False : False : NonNegativeIntegers
    ('A', 'C', 'Type2') :     0 :   5.0 :  None : False : False : NonNegativeIntegers
    ('F', 'B', 'Type1') :     0 :   4.0 :  None : False : False : NonNegativeIntegers
    ('F', 'B', 'Type2') :     0 :   0.0 :  None : False : False : NonNegativeIntegers
    ('F', 'C', 'Type1') :     0 :   0.0 :  None : False : False : NonNegativeIntegers
    ('F', 'C', 'Type2') :     0 :   7.0 :  None : False : False : NonNegativeIntegers
ratio_limit : Size=1, Index=ratio_pairs, Active=True
    Key                : Lower : Body                                                                                                                                                : Upper : Active
    ('Type1', 'Type2') :   0.0 : (send[A,B,Type1] + send[A,C,Type1] + send[F,B,Type1] + send[F,C,Type1])*3 - (send[A,B,Type2] + send[A,C,Type2] + send[F,B,Type2] + send[F,C,Type2]) :   0.0 :   True
# ==========================================================
# = Solver Results                                         =
# ==========================================================
# ----------------------------------------------------------
#   Problem Information
# ----------------------------------------------------------
Problem: 
- Name: unknown
  Lower bound: 1598.0
  Upper bound: 1598.0
  Number of objectives: 1
  Number of constraints: 11
  Number of variables: 9
  Number of nonzeros: 33
  Sense: minimize
# ----------------------------------------------------------
#   Solver Information
# ----------------------------------------------------------
Solver: 
- Status: ok
  Termination condition: optimal
  Statistics: 
    Branch and bound: 
      Number of bounded subproblems: 1
      Number of created subproblems: 1
  Error rc: 0
  Time: 0.00722813606262207
# ----------------------------------------------------------
#   Solution Information
# ----------------------------------------------------------
Solution: 
- number of solutions: 0
  number of solutions displayed: 0
send : Size=8, Index=send_index
    Key                 : Lower : Value : Upper : Fixed : Stale : Domain
    ('A', 'B', 'Type1') :     0 :   4.0 :  None : False : False : NonNegativeIntegers
    ('A', 'B', 'Type2') :     0 :   0.0 :  None : False : False : NonNegativeIntegers
    ('A', 'C', 'Type1') :     0 :   0.0 :  None : False : False : NonNegativeIntegers
    ('A', 'C', 'Type2') :     0 :   5.0 :  None : False : False : NonNegativeIntegers
    ('F', 'B', 'Type1') :     0 :   0.0 :  None : False : False : NonNegativeIntegers
    ('F', 'B', 'Type2') :     0 :   0.0 :  None : False : False : NonNegativeIntegers
    ('F', 'C', 'Type1') :     0 :   0.0 :  None : False : False : NonNegativeIntegers
    ('F', 'C', 'Type2') :     0 :   7.0 :  None : False : False : NonNegativeIntegers
[Finished in 631ms]

Answer 2

您没有显示您的任何代码（如果您需要详细的帮助，通常不是一个好主意......）但是，大概您有一些决策变量是 integer 绑定，代表从您的单一开始到other车站的货车数量，正确的？

然后，在伪代码中：

send_wagons[type, destination] ∈ {integers}  # your decision variable

你有一些目的地的比率：

ratios = {'B': (1, 3), 'C': ...}

然后您可以对每个目的地进行约束以强制执行该比率

for d in destinations:
  send_wagons[type_1, d] * ratios[d][0] == send_wagons[type_2, d] * ratios[d][1]

不要使用除法，因为你会得到会导致问题的数字错误。

如果你有超过 1 种启动或超过 2 种类型的货车，它会变得更复杂，但这是基本的想法