关键词：Python、调包、线性规划、指派问题、运输问题、pulp、混合整数线性规划（MILP）
注：此文章是线性规划的调包实现，具体步骤原理请搜索具体解法。
本文章的各个问题可能会采用多种调用方法，为什么？因为这些包各有特点，有些语法特别像matlab，只要稍稍改变即可达成代码交换；而有些包利用了python本身的特性，在灵活度与代码的可读性上更高。我认为这些包各有优劣，各位各持所需吧。
看了本文章能做到什么？你可以在本文章内学到线性规划的几个问题的求解方式，并学会如何用pulp包解决线性规划问题。无论是整数规划（Integer Program）、01规划（Binary Program）还是混合整数线性规划（MILP），你都可以得到很好的解题方法。
一、线性规划
该问题引用自《数学建模算法与应用-司守奎》第一章线性规划 3.线性规划
包的具体使用可参考scipy官网
求解最普通的线性规划问题：
scipy调包代码
import numpy as np
z = np.array([2, 3, 1])
a = np.array([[1, 4, 2], [3, 2, 0]])
b = np.array([8, 6])
x1_bound = x2_bound = x3_bound =(0, None)
from scipy import optimize
res = optimize.linprog(z, A_ub=-a, b_ub=-b,bounds=(x1_bound, x2_bound, x3_bound))
print(res)
#output:
# fun: 7.0
# message: ‘Optimization terminated successfully.‘
# nit: 2
# slack: array([0., 0.])
# status: 0
# success: True
# x: array([0.8, 1.8, 0. ])
注意，此函数和matlab的linprog有很多相似之处。
首先默认就是求解最小值，如果想要求最大值，需要对目标函数的各参数取反（既对z取反），并在得出的结果（func）前取反。
并且所有约束条件都为≤，因此例子中传入参数是前面都加了负号。
bound为边界的二元元组，None时为无边界。
如果存在类似
这种情况，可以：
A_eq = [[1,2,4]]
b_eq = [101]
并在linprog中传入。
得出的结果为scipy.optimize.optimize.OptimizeResult（优化结果）类型，是类似字典的结构，例如想要优化结果代入目标函数的值，可以res.fun或res[‘fun‘]这样取值。
pulp调包代码
import pulp
#目标函数的系数
z = [2, 3, 1]
#约束
a = [[1, 4, 2], [3, 2, 0]]
b = [8, 6]
#确定最大化最小化问题，最大化只要把Min改成Max即可
m = pulp.LpProblem(sense=pulp.LpMinimize)
#定义三个变量放到列表中
x = [pulp.LpVariable(f‘x{i}‘, lowBound=0) for i in [1,2,3]]
#定义目标函数，lpDot可以将两个列表的对应位相乘再加和
#相当于z[0]*x[0]+z[1]*x[0]+z[2]*x[2]
m += pulp.lpDot(z, x)
#设置约束条件
for i in range(len(a)):
m += (pulp.lpDot(a[i], x) >= b[i])
#求解
m.solve()
#输出结果
print(f‘优化结果：{pulp.value(m.objective)}‘)
print(f‘参数取值：{[pulp.value(var) for var in x]}‘)
#output:
#优化结果：7.0
#参数取值：[2.0, 0.0, 3.0]
每一步的说明已经注释在代码中，可以看到输出结果，两者的变量取值并不一致，但代入目标函数的结果都是一样的。
同样的，如果存在类似这种情况，可以：
A_eq = [1,2,4]
b_eq = 101
m += (pulp.lpDot(A_eq, x) == b_eq)
二、运输问题
某商品有
个产地、
个销地，各产地的产量分别为
，各销地的 需求量分别为
。若该商品由
产地运到
销地的单位运价为
，问应该如何调 运才能使总运费最省？
引入变量
，其取值为由产地运往销地的该商品数量，数学模型为 :
例题：
pulp调包代码
import pulp
import numpy as np
from pprint import pprint
def transportation_problem(costs, x_max, y_max):
row = len(costs)
col = len(costs[0])
prob = pulp.LpProblem(‘Transportation Problem‘, sense=pulp.LpMaximize)
var = [[pulp.LpVariable(f‘x{i}{j}‘, lowBound=0, cat=pulp.LpInteger) for j in range(col)] for i in range(row)]
flatten = lambda x: [y for l in x for y in flatten(l)] if type(x) is list else [x]
prob += pulp.lpDot(flatten(var), costs.flatten())
for i in range(row):
prob += (pulp.lpSum(var[i]) <= x_max[i])
for j in range(col):
prob += (pulp.lpSum([var[i][j] for i in range(row)]) <= y_max[j])
prob.solve()
return {‘objective‘:pulp.value(prob.objective), ‘var‘: [[pulp.value(var[i][j]) for j in range(col)] for i in range(row)]}
然后构造参数传递进去：
if __name__ == ‘__main__‘:
costs = np.array([[500, 550, 630, 1000, 800, 700],
[800, 700, 600, 950, 900, 930],
[1000, 960, 840, 650, 600, 700],
[1200, 1040, 980, 860, 880, 780]])
max_plant = [76, 88, 96, 40]
max_cultivation = [42, 56, 44, 39, 60, 59]
res = transportation_problem(costs, max_plant, max_cultivation)
print(f‘最大值为{res["objective"]}‘)
print(‘各变量的取值为：‘)
pprint(res[‘var‘])
#output:
#最大值为284230.0
#各变量的取值为：
#[[0.0, 0.0, 6.0, 39.0, 31.0, 0.0],
# [0.0, 0.0, 0.0, 0.0, 29.0, 59.0],
# [2.0, 56.0, 38.0, 0.0, 0.0, 0.0],
# [40.0, 0.0, 0.0, 0.0, 0.0, 0.0]]
三、指派问题
该问题引用自《数学建模算法与应用-司守奎》第一章线性规划 3.指派问题
调包解决方法参考https://blog.csdn.net/your_answer/article/details/79160045
可参考官网https://docs.scipy.org/doc/scipy-0.18.1/reference/generated/scipy.optimize.linear_sum_assignment.html
拟分配n人去干项工作，没人干且仅干一项工作，若分配第人去干第项工作，需花费单位时间，问应如何分配工作才能使公认花费的总时间最少？
假设指派问题的系数矩阵为：
引入变量，若分配干工作，则取
，否则取
，上述指派问题的数学模型为
指派问题的可行解用矩阵表示，每行每列有且只有一个元素为1，其余元素均为0。
调用scipy解决
原书使用匈牙利算法解决的，在这里我们用scipy的优化模块解决
import numpy as np
from scipy.optimize import linear_sum_assignment
引入包，linear_sum_assignment是专门用于解决指派问题的模块。
efficiency_matrix = np.array([
[12,7,9,7,9],
[8,9,6,6,6],
[7,17,12,14,12],
[15,14,6,6,10],
[4,10,7,10,6]
])
row_index, col_index=linear_sum_assignment(efficiency_matrix)
print(row_index+1)
print(col_index+1)
print(efficiency_matrix[row_index,col_index])
#output：
#[1 2 3 4 5]
#[2 3 1 4 5]
#[7 6 7 6 6]
定义了开销矩阵（指派问题的系数矩阵）efficiency_matrix，传入linear_sum_assignment，结果返回的是最优指派的行和列，例如第一行选择第二列，意为：将第一个人派往第二个工作。而根据numpy.array的性质，传入行和列就会返回行列所对应的值，即为输出的第三列
print(efficiency_matrix[row_index, col_index].sum())
#output：
# 32
对其求和，即可得到指派问题的最小时间。
调用pulp解决
先定义通用解决方法，其中的flatten是递归展开列表用的。
def assignment_problem(efficiency_matrix):
row = len(efficiency_matrix)
col = len(efficiency_matrix[0])
flatten = lambda x: [y for l in x for y in flatten(l)] if type(x) is list else [x]
m = pulp.LpProblem(‘assignment‘, sense=pulp.LpMinimize)
var_x = [[pulp.LpVariable(f‘x{i}{j}‘, cat=pulp.LpBinary) for j in range(col)] for i in range(row)]
m += pulp.lpDot(efficiency_matrix.flatten(), flatten(var_x))
for i in range(row):
m += (pulp.lpDot(var_x[i], [1]*col) == 1)
for j in range(col):
m += (pulp.lpDot([var_x[i][j] for i in range(row)], [1]*row) == 1)
m.solve()
print(m)
return {‘objective‘:pulp.value(m.objective), ‘var‘: [[pulp.value(var_x[i][j]) for j in range(col)] for i in range(row)]}
然后定义矩阵，输入求解
efficiency_matrix = np.array([
[12, 7, 9, 7, 9],
[8, 9, 6, 6, 6],
[7, 17, 12, 14, 9],
[15, 14, 6, 6, 10],
[4, 10, 7, 10, 9]
])
res = assignment_problem(efficiency_matrix)
print(f‘最小值{res["objective"]}‘)
print(res[‘var‘])
#output
#最小值32.0
#[[0.0, 1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0, 1.0], [0.0, 0.0, 1.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0, 0.0]]
四、pulp的使用方式
基本使用
可以看出，pulp在线性规划这一部分，有更多的通用性，编写程序更自由。前面的例子已经足够丰富了，但是如果读到这里还不去清楚pulp的使用方式的话……可以去百度一下，我这里也简单讲一讲。
首先是定义一个问题，第一个参数为问题的名称，不过并非必要的参数，而通过sense参数可决定优化的是最大值还是最小值
prob = pulp.LpProblem(‘problem name‘, sense=pulp.LpMinimize)
然后是定义变量：
x0 = pulp.LpVariable(‘x0‘, lowBound=0, upBound=None, cat=pulp.LpInteger)
x1 = pulp.LpVariable(‘x1‘, lowBound=0, upBound=None, cat=pulp.LpInteger)
x2 = pulp.LpVariable(‘x2‘, lowBound=0, upBound=None, cat=pulp.LpInteger)
这里定义了三个变量，第一个参数为变量名，lowBound 、upBound为上下限，cat为变量类型，默认为连续变量，还可以设为离散变量或二值变量，具体怎么设置？
如上述代码所示，pulp.LpInteger为离散变量，pulp.LpBinary为二值变量，同时也可以传入‘Integer‘字符串的方式指明变量类型。从上面几个问题的代码可以看出，我几乎没有单个定义变量，而是批量定义的。
然后是添加目标函数：
prob += 2*x0-5*x1+4*x2
只要让问题（prob）直接加变量的表达式即可添加目标函数。
再之后是添加约束：
prob += (x0+x1-6*x2 <= 120)
只要让问题（prob）直接加变量的判断式即可添加约束
prob.solve()
调用solve方法解出答案，如果省去这一步，后面的变量和结果值都会显示None。
print(pulp.value(prob.objective))
print(pulp.value(x0))
打印优化结果，并显示当优化达到结果时x0的取值。
思考程序本质
problem对象是如何通过不断加来获得目标函数和约束的？熟悉python或者c++的朋友可能会想到一个词：操作符重载。
没错，就是这么实现的，上述的对象几乎都实现了不同的重载。
首先是Problem对象prob，全名pulp.pulp.LpProblem；当打印输出（print）时，会打印出问题名，当不断增加目标函数、约束时，也会随着print输出；而它的__add__一定是被定义过了，我们先说其他对象。
当我们定义一个变量时，它的类型是pulp.pulp.LpVariable，当我们对这些变量和其他变量做加法、和其他常数做乘法时，它会返回一个新的对象，经检测，这个新对象的类名叫pulp.pulp.LpAffineExpression，顾名思义，叫做关系表达式；如果print，会打印这个关系表达式。
而如果对关系表达式做出：>=、<=、==时，会返回新的对象，类名叫做pulp.pulp.LpConstraint，即约束对象；如果print，会打印这个约束。
将关系表达式（pulp.pulp.LpAffineExpression）与问题（pulp.pulp.LpProblem）相加时，会返回新的问题对象，并且新的问题对象会将这个关系表达式作为目标函数。
将约束对象（pulp.pulp.LpConstraint）与问题（pulp.pulp.LpProblem）相加时，会返回新的问题对象，并且这个新的问题对象会多出约束对象所代表的约束条件。
调用问题对象的solve方法，解出线性规划的解。
访问问题对象的objective成员变量，会得到目标函数（关系表达式对象）。
调用pulp的value方法，将获得对变量代入值的结果，如果是关系表达式对象，将获得优化结果；如果是变量对象，将获得优化结果达到时的变量取值；如果是None，说明你忘调用solve了。
这个包的使用，我是在google中查到的，如果有兴趣，可以去原地址看看，拥有更多的应用以及其他包的调用https://qiita.com/SaitoTsutomu/items/bfbf4c185ed7004b5721
也可以去bilibili看看相关的视频https://www.bilibili.com/video/av18818604?from=search&seid=17463693264345909709
作者：crossous
链接：https://www.jianshu.com/p/9be417cbfebb
来源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。
原文地址：https://www.cnblogs.com/caiyishuai/p/11175373.html