〖探索python〗使用 Pyomo 解决复杂的问题（九）

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

来自IBM DEVELOPERWORKS

探索在 Python 中使用 Python Optimization Modeling Objects（Pyomo，一个开源工具）建模优化应用程序的方法。您可以使用 Pyomo 定义象征性的问题，创建具体的问题实例，并使用标准解算器解决这些实例。本系列文章将展示如何利用 Pyomo 的能力集成 Python 来建模优化应用程序。本系列的第一篇文章将介绍基础知识。第 2 部分将介绍如何添加更多工具和构建一种可伸缩的架构。第 3 部分将提供一些使用 IPython 和 pandas 进行投资分析和统计分析的实用示例。



简介

---

建模是一种解决复杂问题的强大方法。依据图书 Modeling Languages in Mathematical Optimization（参阅 参考资料）的叙述，模型用于：

• 解释现象
  
• 进行预测
  
• 评估关键因素
  
• 识别极限
  
• 分析折衷方法
  
  

在业界，Microsoft® Excel 等电子表格软件常常是建模问题的首要选择。现在，电子表格通常非常直观，但它们在解决大型问题上存在着局限性。如果您是开发人员，那么您可能会发现编写脚本来解决建模问题会更有效，因为您可以轻松地将脚本集成到其他系统中。本文将介绍使用 Pyomo 库在 Python 应用中实现线性优化的基础知识。

入门

---

首先要安装 Pyomo。Pyomo 是 Coopr 的一个中心组件，而 Coopr 是 Python 软件包的集合。您可以下载 coopr_install 脚本，在使用 Python 解释器运行它时，它会创建一个 Python 虚拟环境。

创建一个名为 “coopr” 的相对目录：

1. noahs-MacBook-Air% python coopr_install

复制代码

使用下面的命令启动 Pyomo，这会将该相对目录和它的可执行文件放在您的路径中：

1. noahs-MacBook-Air% source coopr/bin/activate

复制代码

使用 Pyomo "--help 命令获取使用 pyomo 的帮助：

1. (coopr)noahs-MacBook-Air% pyomo --help

复制代码

您需要一个编译器来使用虚拟 Python 环境构建器 (virtualenv) 和 Pyomo。在 OS X 上，使用 XCode Developer Tools 命令行工具。在 Linux 上，使用 GNU Compiler Collection (GCC)。初始化这个虚拟环境后，可通过以下两种方式之一使用 Pyomo 解决问题：

• 使用 Pyomo 命令行工具：
  1. (coopr)noahs-MacBook-Air% pyomo my_problem.py --solver=glpk

  复制代码
  
  
• 或者，将初始化代码嵌入您的脚本中，通过 Python 解释器运行它：清单 1. 在一个脚本中调用 Pyomo
  1. #This is an optional code path that allows the script to be run outside of
     
  2. #pyomo command-line.  For example:  python wyndor.py
     
  3. if __name__ == '__main__':
     
  4.    
     
  5.     #This replicates what the pyomo command-line tools does
     
  6.     from coopr.opt import SolverFactory
     
  7.     opt = SolverFactory("glpk")
     
  8.     instance = model.create()
     
  9.     results = opt.solve(instance)
     
  10.     #sends results to stdout
      
  11.     results.write()

  复制代码
  
  

Pyomo 假设您至少安装了一个解算器 (solver)。GNU Linear Programming Kit (glpk) 是默认的解算器。请参阅您希望使用的解算器的安装说明。然后确保 Pyomo 能够在它的路径上找到此解算器。

建模策略

---

可通过两种方式使用 Pyomo 创建数据模型：抽象方式和具体方式。二者的关键区别在于是否将模型与数据分开。

• 在抽象模型中，模型与数据是分开的。
  
• 在具体模型中，是在模型本身中定义数据的。例如，在使用具体模型的 Pyomo 脚本中，所有内容都是在单个脚本文件中定义的。对于更简单的问题，尤其是教学问题，这可能是一种很高效的方法。但在另一方面，更大的问题通常是拥有更大的数据集，这使得将数据和处理该数据所需的代码嵌入同一个脚本中变得不切实际。
  
  

从总体上讲，Pyomo 模型由变量（variables）、目标（objectives）和约束（constraints）组成。

• 变量是在优化期间计算的值。
  
• 目标是获取数据和变量的 Python 函数，它要么是最大值，要么是最小值。
  
• 约束是定义表达式来限制变量可使用的值的一种方式。
  
  

在创建 Pyomo 模型时，需要了解表示代数表达式的 Python 方法。下面的摘要简单对比了电子表格、代数和 Python 中的表达式：

图 1. 符号对比表
Pyomo 应用程序示例：Wyndor

为了演示使用 Pyomo 时的一个简单的线性优化问题，我们以图书 Introduction to Management Science 中的一个产品组合问题为例（参阅 参考资料）。Wyndor 工厂负责生产门窗，它的三个厂房有不同的营业时间，可以生产门或窗。要确定如何最大程度地提高有限生产时间内的可用利润，可以编写以下脚本。该脚本包含三个主要部分：模型、目标和约束。

• 模型（一个具体模型）实例化问题的数据，比如厂房的营业时间。
  
• 目标（可以是最大值或最小值）是最大的利润。
  
• 约束使用了一个 CapacityRule 函数，该函数使用一种称为列表推导式 的 Python 语言来编写。
  
  

以下是 Wyndor 优化问题的脚本：

清单 2. Wyndor Pyomo 基本示例

1. """Wyndor model from Hillier and Hillier *Introduction to Management Science*
   
2. 
   
3. One way to do it...
   
4. Original Author dlw
   
5. Modified ndg
   
6. 
   
7. To run this you need pyomo and the glpk solver installed, and need to be
   
8. inside of the virtual environment.
   
9. When these dependencies are installed you can solve this way (glpk is default):
   
10.    
    
11.     pyomo wyndor.py
    
12. 
    
13. """
    
14. 
    
15. #Explicit importing makes it more clear what a user needs to define
    
16. #versus what is included within the pyomo library
    
17. from coopr.pyomo import (ConcreteModel, Objective, Var, NonNegativeReals,
    
18.                               maximize, Constraint)
    
19. 
    
20. Products = ['Doors', 'Windows']
    
21. ProfitRate = {'Doors':300, 'Windows':500}
    
22. Plants = ['Door Fab', 'Window Fab', 'Assembly']
    
23. HoursAvailable = {'Door Fab':4, 'Window Fab':12, 'Assembly':18}
    
24. HoursPerUnit = {('Doors','Door Fab'):1, ('Windows', 'Window Fab'):2,
    
25.                 ('Doors','Assembly'):3, ('Windows', 'Assembly'):2,
    
26.                 ('Windows', 'Door Fab'):0, ('Doors', 'Window Fab'):0}
    
27. 
    
28. #Concrete Model
    
29. model = ConcreteModel()
    
30. #Decision Variables
    
31. model.WeeklyProd = Var(Products, within=NonNegativeReals)
    
32. 
    
33. #Objective
    
34. model.obj = Objective(expr=
    
35.             sum(ProfitRate[i] * model.WeeklyProd[i] for i in Products),
    
36.             sense = maximize)
    
37. 
    
38. def CapacityRule(model, p):
    
39.     """User Defined Capacity Rule
    
40.    
    
41.     Accepts a pyomo Concrete Model as the first positional argument,
    
42.     and and a plant index as a second positional argument
    
43.     """
    
44.    
    
45.     return sum(HoursPerUnit[i,p] * model.WeeklyProd[i] for i in Products)
    
46.           <= HoursAvailable[p]
    
47. 
    
48. This statement is what Pyomo needs to generate one constraint for each plant
    
49. model.Capacity = Constraint(Plants, rule = CapacityRule)
    
50. 
    
51. #This is an optional code path that allows the script to be run outside of
    
52. #pyomo command-line.  For example:  python wyndor.py
    
53. if __name__ == '__main__':
    
54.    
    
55.     #This replicates what the pyomo command-line tools does
    
56.     from coopr.opt import SolverFactory
    
57.     opt = SolverFactory("glpk")
    
58.     instance = model.create()
    
59.     results = opt.solve(instance)
    
60.     #sends results to stdout
    
61.     results.write()

复制代码

让我们运行以下脚本：

1. (coopr)noahs-MacBook-Air% pyomo wyndor.py

复制代码

Pyomo 返回以下输出，该输出显示了一个可行的解决方案（可实现 3,600 美元的利润）：

清单 3. 一个可实现 3,600 美元的利润的可行解决方案

1.     (coopr)noahs-MacBook-Air% pyomo wyndor.py  
   
2. [    0.00] Setting up Pyomo environment
   
3. [    0.00] Applying Pyomo preprocessing actions
   
4. [    0.00] Creating model
   
5. [    0.00] Applying solver
   
6. [    0.01] Processing results
   
7.     Number of solutions: 1
   
8.     Solution Information
   
9.       Gap: 0.0
   
10.       Status: feasible
    
11.       Function Value: 3600.0
    
12.     Solver results file: results.json
    
13. [    0.02] Applying Pyomo postprocessing actions
    
14. [    0.02] Pyomo Finished

复制代码

我们看看您应生产的产品的比率。为此，对输出文件 results.json 运行 cat。结果如下：

1. "Variable": {
   
2.                 "WeeklyProd[Doors]": {
   
3.                     "Id": 0,
   
4.                     "Value": 2.0
   
5.                 },
   
6.                 "WeeklyProd[Windows]": {
   
7.                     "Id": 1,
   
8.                     "Value": 6.0

复制代码

在输出中，可以看到生产 6 个窗子和 2 个门会得到 3,600 美元的最大利润。

解决该脚本的另一种方法是使用 Python，这得益于所添加的条件语句。这会在脚本内调用 Pyomo，而不是使用 Pyomo 调用脚本。

启发式优化：贪婪的随机流动推销员

---

Bill Cook 编写的图书 In Pursuit of the Traveling Salesman: Mathematics at the Limits of Computation 中包含一个优秀的问题示例，该问题并不总是像线性程序一样得到良好扩展。这个问题就是流动推销员问题或 TSP：在给定一个城市列表的情况下，找出仅访问每个城市一次并且最后回到最初的城市的最短路线。随着城市数量的增多，在最坏情况下，解决流动推销员问题的时间会呈指数级增长。

图 2 中的图表模拟了解决每种可能的路线所需的时间，假设只需几秒即可解决几个城市的问题。如您所见，在您的有生之年解决这个问题很快就会变得行不通。

图 2. 流动推销员问题的解决时间呈指数级增长

您需要另一种方法来查找良好的 结果。通常，通过运行模拟，然后获取这些模拟的最佳结果，可以实现良好 但不一定最佳的解决方案。此方法的一个示例如下面的 Python 代码所示。随机选择一个开始城市，然后贪婪地 选择下一个具有最短距离的城市。这种模拟然后可运行多次，然后将得到这些模拟中的最短路径。

清单 4. 贪婪最短距离选择

1. noahs-MacBook-Air% python tsp_greedy_random_start.py 20
   
2. Running simulation 20 times
   
3. Shortest Distance: 128
   
4. Optimal Route: [
   
5. ('PCG', 'GPS', 1),
   
6. ('GPS', 'URS', 1),
   
7. ('URS', 'WFC', 0),
   
8. ('WFC', 'MCK', 2),
   
9. ('MCK', 'SFO', 16),
   
10. ('SFO', 'ORCL', 20),
    
11. ('ORCL', 'HPQ', 12),
    
12. ('HPQ', 'GOOG', 6),
    
13. ('GOOG', 'AAPL', 11),
    
14. ('AAPL', 'INTC', 8),
    
15. ('INTC', 'CSCO', 6),
    
16. ('CSCO', 'EBAY', 0),
    
17. ('EBAY', 'SWY', 32),
    
18. ('SWY', 'CVX', 13)
    
19. ]

复制代码

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏1 回帖

关键词：python Pyomo OMO Optimization introduction python

清单 5. TSP 贪婪随机起点

1. #!/usr/bin/env python
   
2. """
   
3. Traveling salesman solution with random start and greedy path selection
   
4. You can select how many iterations to run by doing the following:
   
5. 
   
6. python tsp_greedy_random_start.py 20 #runs 20 times
   
7. 
   
8. 
   
9. """
   
10. 
    
11. import sys
    
12. from random import choice
    
13. import numpy as np
    
14. from routes import values
    
15. 
    
16. dt = np.dtype([('city_start', 'S10'), ('city_end', 'S10'), ('distance', int)])
    
17. data_set = np.array(values,dtype=dt)
    
18. 
    
19. def all_cities(mdarray):
    
20.     """Takes a multi-dimensional array in this format and finds unique cities
    
21.    
    
22.     array([["A", "A"],
    
23.     ["A", "B"]])
    
24.    
    
25.     """
    
26.     cities = {}
    
27.     city_set = set(data_set['city_end'])
    
28.     for city in city_set:
    
29.         cities[city] = ""
    
30.     return cities
    
31.    
    
32. def randomize_city_start(all_cities):
    
33.     """Returns a randomized city to start trip"""
    
34.    
    
35.     return choice(all_cities)
    
36. 
    
37. def get_shortest_route(routes):
    
38.     """Sort the list by distance and return shortest distance route"""
    
39. 
    
40.     route = sorted(routes, key=lambda dist: dist[2]).pop(0)
    
41.     return route
    
42. 
    
43. def greedy_path():
    
44.     """Select the next path to travel based on the shortest, nearest path"""
    
45. 
    
46.     itinerary = []
    
47.     cities = all_cities(data_set)
    
48.     starting_city = randomize_city_start(cities.keys())
    
49.     #print "starting_city: %s" % starting_city
    
50.     cities_visited = {}
    
51.     #we want to iterate through all cities once
    
52.     count = 1
    
53.     while True:
    
54.         possible_routes = []
    
55.         distance = []
    
56.         #print "starting city: %s" % starting_city
    
57.         for path in data_set:
    
58.             if starting_city in path['city_start']:
    
59.                 #we can't go to cities we have already visited
    
60.                 if path['city_end'] in cities_visited:
    
61.                     continue
    
62.                 else:
    
63.                     #print "path: ", path
    
64.                     possible_routes.append(path)
    
65.         
    
66.         if not possible_routes:
    
67.             break
    
68.         #append this to itinerary
    
69.         route = get_shortest_route(possible_routes)
    
70.         #print "Route(%s): %s " % (count, route)
    
71.         count += 1
    
72.         itinerary.append(route)
    
73.         #add this city to the visited city list
    
74.         cities_visited[route[0]] = count
    
75.         #print "cities_visited: %s " % cities_visited
    
76.         #reset the starting_city to the next city
    
77.         starting_city = route[1]
    
78.         #print "itinerary: %s" % itinerary
    
79.    
    
80.     return itinerary
    
81. 
    
82. def get_total_distance(complete_itinerary):
    
83.    
    
84.     distance = sum(z for x,y,z in complete_itinerary)
    
85.     return distance
    
86. 
    
87. def lowest_simulation(num):
    
88.    
    
89.     routes = {}
    
90.     for i in range(num):
    
91.         itinerary = greedy_path()
    
92.         distance = get_total_distance(itinerary)
    
93.         routes[distance] = itinerary
    
94.     shortest_distance = min(routes.keys())
    
95.     route = routes[shortest_distance]
    
96.     return shortest_distance, route
    
97. 
    
98. def main():
    
99.     """runs everything"""
    
100.    
     
101.     if len(sys.argv) == 2:
     
102.         iterations = int(sys.argv[1])
     
103.         print "Running simulation %s times" % iterations
     
104.         distance, route = lowest_simulation(iterations)
     
105.         print "Shortest Distance: %s" % distance
     
106.         print "Optimal Route: %s" % route
     
107.     else:
     
108.         #print "All Routes: %s" % data_set
     
109.         itinerary = greedy_path()
     
110.         print "itinerary: %s" % itinerary
     
111.         print "Distance: %s" % get_total_distance(itinerary)
     
112.    
     
113. 
     
114. if __name__ == '__main__':
     
115.    main()

复制代码

上述 TSP 脚本使用了一个 NumPy 多维数组作为数据来源。如果希望运行此示例，则需要安装 NumPy（参阅 参考资料）。该数组是在一个名为 routes.py 的文件中定义的。以下是可能的路线。

清单 6. 包含城市间路线的 NumPy 多维数组

1. values = [
   
2. ("AAPL", "CSCO", 14),
   
3. ("AAPL", "CVX", 44),
   
4. ("AAPL", "EBAY", 14),
   
5. ("AAPL", "GOOG", 14),
   
6. ("AAPL", "GPS", 59),
   
7. ("AAPL", "HPQ", 14),
   
8. ("AAPL", "INTC", 8),
   
9. ("AAPL", "MCK", 60),
   
10. ("AAPL", "ORCL", 26),
    
11. ("AAPL", "PCG", 59),
    
12. ("AAPL", "SFO", 46),
    
13. ("AAPL", "SWY", 37),
    
14. ("AAPL", "URS", 60),
    
15. ("AAPL", "WFC", 60),
    
16. 
    
17. ("CSCO","AAPL" ,14),
    
18. ("CSCO", "CVX", 43),
    
19. ("CSCO", "EBAY",0),
    
20. ("CSCO", "GOOG",21),
    
21. ("CSCO", "GPS",67),
    
22. ("CSCO", "HPQ",26),
    
23. ("CSCO", "INTC",6),
    
24. ("CSCO", "MCK",68),
    
25. ("CSCO", "ORCL",37),
    
26. ("CSCO", "PCG",68),
    
27. ("CSCO", "SFO",57),
    
28. ("CSCO", "SWY",32),
    
29. ("CSCO", "URS",68),
    
30. ("CSCO", "WFC",68),
    
31. 
    
32. ("CVX","AAPL" ,44),
    
33. ("CVX", "CSCO",43),
    
34. ("CVX", "EBAY",43),
    
35. ("CVX", "GOOG",36),
    
36. ("CVX", "GPS",43),
    
37. ("CVX", "HPQ",40),
    
38. ("CVX", "INTC",41),
    
39. ("CVX", "MCK",46),
    
40. ("CVX", "ORCL",39),
    
41. ("CVX", "PCG",44),
    
42. ("CVX", "SFO",45),
    
43. ("CVX", "SWY",13),
    
44. ("CVX", "URS",44),
    
45. ("CVX", "WFC",44),
    
46. 
    
47. ("EBAY","AAPL" ,14),
    
48. ("EBAY", "CSCO",0),
    
49. ("EBAY", "CVX",43),
    
50. ("EBAY", "GOOG",21),
    
51. ("EBAY", "GPS",67),
    
52. ("EBAY", "HPQ",26),
    
53. ("EBAY", "INTC",6),
    
54. ("EBAY", "MCK",68),
    
55. ("EBAY", "ORCL",37),
    
56. ("EBAY", "PCG",68),
    
57. ("EBAY", "SFO",57),
    
58. ("EBAY", "SWY",32),
    
59. ("EBAY", "URS",68),
    
60. ("EBAY", "WFC",68),
    
61. 
    
62. ("GOOG","AAPL",11),
    
63. ("GOOG", "CSCO",21),
    
64. ("GOOG", "CVX",36),
    
65. ("GOOG", "EBAY",21),
    
66. ("GOOG", "GPS",48),
    
67. ("GOOG", "HPQ",6),
    
68. ("GOOG", "INTC",15),
    
69. ("GOOG", "MCK",49),
    
70. ("GOOG", "ORCL",16),
    
71. ("GOOG", "PCG",48),
    
72. ("GOOG", "SFO",36),
    
73. ("GOOG", "SWY",32),
    
74. ("GOOG", "URS",49),
    
75. ("GOOG", "WFC",49),
    
76. 
    
77. ("GPS","AAPL" ,59),
    
78. ("GPS", "CSCO",67),
    
79. ("GPS", "CVX",43),
    
80. ("GPS", "EBAY",67),
    
81. ("GPS", "GOOG",48),
    
82. ("GPS", "HPQ",45),
    
83. ("GPS", "INTC",62),
    
84. ("GPS", "MCK",03),
    
85. ("GPS", "ORCL",34),
    
86. ("GPS", "PCG",01),
    
87. ("GPS", "SFO",18),
    
88. ("GPS", "SWY",53),
    
89. ("GPS", "URS",01),
    
90. ("GPS", "WFC",01),
    
91. 
    
92. ("HPQ","AAPL" ,14),
    
93. ("HPQ", "CSCO",26),
    
94. ("HPQ", "CVX",40),
    
95. ("HPQ", "EBAY",26),
    
96. ("HPQ", "GOOG",6),
    
97. ("HPQ", "GPS",45),
    
98. ("HPQ", "INTC",20),
    
99. ("HPQ", "MCK",46),
    
100. ("HPQ", "ORCL",12),
     
101. ("HPQ", "PCG",46),
     
102. ("HPQ", "SFO",32),
     
103. ("HPQ", "SWY",37),
     
104. ("HPQ", "URS",46),
     
105. ("HPQ", "WFC",46),
     
106. 
     
107. ("INTC","AAPL",8),
     
108. ("INTC","CSCO",6),
     
109. ("INTC", "CVX",41),
     
110. ("INTC", "EBAY",6),
     
111. ("INTC", "GOOG",15),
     
112. ("INTC", "GPS",62),
     
113. ("INTC", "HPQ",20),
     
114. ("INTC", "MCK",63),
     
115. ("INTC", "ORCL",31),
     
116. ("INTC", "PCG",62),
     
117. ("INTC", "SFO",51),
     
118. ("INTC", "SWY",32),
     
119. ("INTC", "URS",63),
     
120. ("INTC", "WFC",63),
     
121. 
     
122. ("MCK", "AAPL",60),
     
123. ("MCK", "CSCO",68),
     
124. ("MCK", "CVX",46),
     
125. ("MCK", "EBAY",68),
     
126. ("MCK", "GOOG",49),
     
127. ("MCK", "GPS",03),
     
128. ("MCK", "HPQ",46),
     
129. ("MCK", "INTC",63),
     
130. ("MCK", "ORCL",34),
     
131. ("MCK", "PCG",3),
     
132. ("MCK", "SFO",16),
     
133. ("MCK", "SWY",56),
     
134. ("MCK", "URS",3),
     
135. ("MCK", "WFC",2),
     
136. 
     
137. ("ORCL", "AAPL",22),
     
138. ("ORCL", "CSCO",37),
     
139. ("ORCL", "CVX",39),
     
140. ("ORCL", "EBAY",37),
     
141. ("ORCL", "GOOG",16),
     
142. ("ORCL", "GPS",34),
     
143. ("ORCL", "HPQ",12),
     
144. ("ORCL", "INTC",31),
     
145. ("ORCL", "MCK",34),
     
146. ("ORCL", "PCG",35),
     
147. ("ORCL", "SFO",20),
     
148. ("ORCL", "SWY",40),
     
149. ("ORCL", "URS",35),
     
150. ("ORCL", "WFC",35),
     
151. 
     
152. ("PCG", "AAPL",59),
     
153. ("PCG", "CSCO",68),
     
154. ("PCG", "CVX",44),
     
155. ("PCG", "EBAY",68),
     
156. ("PCG", "GOOG",48),
     
157. ("PCG", "GPS",01),
     
158. ("PCG", "HPQ",46),
     
159. ("PCG", "INTC",62),
     
160. ("PCG", "MCK",03),
     
161. ("PCG", "ORCL",35),
     
162. ("PCG", "SFO",18),
     
163. ("PCG", "SWY",54),
     
164. ("PCG", "URS",01),
     
165. ("PCG", "WFC",01),
     
166. 
     
167. ("SFO", "AAPL",46),
     
168. ("SFO", "CSCO",57),
     
169. ("SFO", "CVX",45),
     
170. ("SFO", "EBAY",57),
     
171. ("SFO", "GOOG",36),
     
172. ("SFO", "GPS",18),
     
173. ("SFO", "HPQ",32),
     
174. ("SFO", "INTC",51),
     
175. ("SFO", "MCK",16),
     
176. ("SFO", "ORCL",20),
     
177. ("SFO", "PCG",18),
     
178. ("SFO", "SWY",52),
     
179. ("SFO", "URS",18),
     
180. ("SFO", "WFC",18),
     
181. 
     
182. ("SWY", "AAPL",37),
     
183. ("SWY", "CSCO",32),
     
184. ("SWY", "CVX",13),
     
185. ("SWY", "EBAY",32),
     
186. ("SWY", "GOOG",32),
     
187. ("SWY", "GPS",53),
     
188. ("SWY", "HPQ",37),
     
189. ("SWY", "INTC",32),
     
190. ("SWY", "MCK",56),
     
191. ("SWY", "ORCL",40),
     
192. ("SWY", "PCG",54),
     
193. ("SWY", "SFO",52),
     
194. ("SWY", "URS",54),
     
195. ("SWY", "WFC",54),
     
196. 
     
197. ("URS", "AAPL",60),
     
198. ("URS", "CSCO",68),
     
199. ("URS", "CVX",44),
     
200. ("URS", "EBAY",68),
     
201. ("URS", "GOOG",49),
     
202. ("URS", "GPS",01),
     
203. ("URS", "HPQ",46),
     
204. ("URS", "INTC",63),
     
205. ("URS", "MCK",03),
     
206. ("URS", "ORCL",35),
     
207. ("URS", "PCG",01),
     
208. ("URS", "SFO",18),
     
209. ("URS", "SWY",54),
     
210. ("URS", "WFC",0),
     
211. 
     
212. ("WFC", "AAPL",60),
     
213. ("WFC", "CSCO",68),
     
214. ("WFC", "CVX",44),
     
215. ("WFC", "EBAY",68),
     
216. ("WFC", "GOOG",49),
     
217. ("WFC", "GPS",01),
     
218. ("WFC", "HPQ",46),
     
219. ("WFC", "INTC",63),
     
220. ("WFC", "MCK",02),
     
221. ("WFC", "ORCL",35),
     
222. ("WFC", "PCG",01),
     
223. ("WFC", "SFO",18),
     
224. ("WFC", "SWY",54),
     
225. ("WFC", "URS",0),
     
226. 
     
227. ]

复制代码

   pyomo不错，和我喜欢的AMPL接合得紧密，就是model生成慢多了，倒是方便，功能也很强大。
   对称TSP求解这个例子倒不宜做pyomo使用的例子，这种问题用concorde, lkh解决就方便多了，而且milp这种模型构建大多数工具都能做啦。

感谢分享。