Pyomo. Моделирование оптимизации на Python Книги [М. Бинум] (pdf) читать онлайн

Книги для программистов: https://t.me/booksforits

Майкл Л. Бинум, Габриэль А. Хакебейл, Уильям Э. Харт,
Карл Д. Лэрд, Бетани Л. Николсон, Джон Д. Сиирола,
Жан-Поль Уотсон, Дэвид Л. Вудраф

Pyomo.
Моделирование оптимизации
на Python

Книги для программистов: https://t.me/booksforits

Michael L. Bynum, Gabriel A. Hackebeil, William E. Hart,
Carl D. Laird, Bethany L. Nicholson, John D. Siirola,
Jean-Paul Watson, David L. Woodruff

Pyomo –
Optimization Modeling
in Python
Third Edition

Книги для программистов: https://t.me/booksforits

Майкл Л. Бинум, Габриэль А. Хакебейл, Уильям Э. Харт,
Карл Д. Лэрд, Бетани Л. Николсон, Джон Д. Сиирола,
Жан-Поль Уотсон, Дэвид Л. Вудраф

Pyomo.
Моделирование
оптимизации на Python

Москва, 2023
Книги для программистов: https://t.me/booksforits

УДК 004.04
ББК 32.372
Б62

Б62

Бинум М. Л., Хакебейл Г. А., Харт У. Э., Лэрд К. Д., Николсон Б. Л.,
Сиирола Д. Д., Уотсон Ж.-П., Вудраф Д. Л.
Pyomo. Моделирование оптимизации на Python / пер. с англ. А. А. Слинкина. – М.: ДМК Пресс, 2023. – 230 с.: ил.
ISBN 978-5-93700-230-3
Эта книга представляет собой полное руководство по Python Optimization
Modeling Objects — пакету с открытым исходным кодом, предназначенному для
формулирования и решения крупномасштабных задач оптимизации. Его можно
использовать как из командной строки, так и из интерактивного окружения Python,
что сильно упрощает создание моделей Pyomo, применение оптимизаторов
и изучение решений. Благодаря многочисленным примерам, иллюстрирующим
различные способы формулирования моделей, книга прекрасно раскрывает широту средств моделирования, поддерживаемых Pyomo, и ее подходы к сложным
практическим приложениям.
Издание предназначено для начинающих и опытных разработчиков моделей,
в том числе студентов старших курсов и аспирантов, научных работников и инженеров-практиков.

УДК 004.04
ББК 32.372
First published in English under the title Pyomo – Optimization Modeling in Python, 3rd ed.
by Michael L. Bynum, Gabriel A. Hackebeil, William E. Hart, Carl D. Laird, Bethany L. Nicholson,
John D. Siirola, Jean-Paul Watson, David L. Woodruff.
This edition has been translated and published under licence from Springer Nature
Switzerland AG. Springer Nature Switzerland AG takes no responsibility and shall not be made
liable for the accuracy of the translation.
Все права защищены. Любая часть этой книги не может быть воспроизведена в какой бы то ни было форме и какими бы то ни было средствами без письменного разрешения
владельцев авторских прав.

ISBN 978-3-030-68927-8 (англ.)
ISBN 978-5-93700-230-3 (рус.)

© Springer Nature Switzerland AG, 2023
© Перевод, оформление, издание,
ДМК Пресс, 2023

Книги для программистов: https://t.me/booksforits

Посвящается пользователям Pyomo –
прошлым, настоящим и будущим

Книги для программистов: https://t.me/booksforits

Содержание

От издательства.......................................................................................................12
Предисловие.............................................................................................................13
Глава 1. Введение....................................................................................................17
1.1. Языки моделирования для оптимизации........................................................17
1.2. Моделирование на Pyomo...................................................................................19
1.2.1. Простые примеры.........................................................................................19
1.2.2. Пример раскраски графа.............................................................................21
1.2.3. Ключевые особенности Pyomo...................................................................24
Python...................................................................................................................24
Настраиваемые возможности. .........................................................................24
Командные инструменты и скрипты..............................................................24
Определение конкретных и абстрактных моделей. .....................................24
Объектно ориентированный дизайн. .............................................................25
Выразительные возможности моделирования. ............................................25
Интеграция с решателями................................................................................25
Открытый исходный код...................................................................................25
1.3. Подготовительные действия..............................................................................26
1.4. Краткий обзор книги...........................................................................................26
1.5. Обсуждение...........................................................................................................27

Часть I. ВВЕДЕНИЕ В PYOMO ..........................................................................28
Глава 2. Математическое моделирование и оптимизация......................29
2.1. Математическое моделирование......................................................................29
2.1.1. Общие сведения............................................................................................29
2.1.2. Пример моделирования. .............................................................................30
2.2. Оптимизация........................................................................................................32
2.3. Моделирование в Pyomo.....................................................................................34
2.3.1. Конкретная формулировка.........................................................................34
2.4. Линейные и нелинейные модели оптимизации.............................................36
2.4.1. Определение..................................................................................................36
2.4.2. Линейная версия...........................................................................................37
2.5. Решение модели Pyomo. .....................................................................................37
2.5.1. Решатели........................................................................................................37
2.5.2. Python-скрипты............................................................................................37
Книги для программистов: https://t.me/booksforits

Содержание  7

Глава 3. Обзор Pyomo. ...........................................................................................39
3.1. Введение................................................................................................................39
3.2. Задача о расположении складов........................................................................40
3.3. Модели Pyomo. .....................................................................................................41
3.3.1. Переменные, целевые функции и ограничения......................................41
3.3.2. Индексированные компоненты.................................................................42
3.3.3. Правила конструирования..........................................................................44
3.3.4. Конкретная модель для задачи о расположении складов......................45
3.3.5. Компоненты моделирования для множеств и параметров...................48

Глава 4. Модели Pyomo и их компоненты: введение................................51
4.1. Объектно ориентированный AML.....................................................................51
4.2. Общие парадигмы компонентов.......................................................................53
4.2.1. Индексированные компоненты.................................................................53
4.3. Переменные..........................................................................................................54
4.3.1. Объявления Var.............................................................................................54
4.3.2. Работа с объектами Var................................................................................57
4.4. Целевые функции. ...............................................................................................57
4.4.1. Объявление Objective...................................................................................58
4.4.2. Работа с объектами Objective......................................................................59
4.5. Ограничения.........................................................................................................59
4.5.1. Объявление Constraint.................................................................................60
4.5.2. Работа с объектами Constraint....................................................................62
4.6. Множества.............................................................................................................62
4.6.1. Объявление Set. ............................................................................................63
4.6.2. Работа с объектами Set................................................................................66
4.7. Параметры.............................................................................................................68
4.7.1. Объявление Param. .......................................................................................68
4.7.2. Работа с объектами Param...........................................................................71
4.8. Именованные выражения. .................................................................................72
4.8.1. Объявление Expression. ...............................................................................73
4.8.2. Работа с объектами Expression...................................................................74
4.9. Суффиксы..............................................................................................................74
4.9.1. Объявления Suffix.........................................................................................75
4.9.2. Работа с суффиксами. ..................................................................................76
4.10. Другие компоненты моделирования..............................................................77

Глава 5. Программирование нестандартных технологических
процессов...................................................................................................................79
5.1. Введение................................................................................................................79
5.2. Опрос модели.......................................................................................................82
5.2.1. Функция value...............................................................................................83
5.2.2. Доступ к атрибутам индексированных компонентов. ...........................84
5.2.2.1. Срезы индексов компонентов.............................................................84
5.2.2.2. Обход всех объектов Var в модели......................................................84
Книги для программистов: https://t.me/booksforits

8  Содержание
5.3. Модификация структуры модели Pyomo. ........................................................85
5.4. Типичные примеры программирования.........................................................86
5.4.1. Цикл по местоположениям складов и построение диаграммы............86
5.4.2. Решатель судоку............................................................................................88

Глава 6. Взаимодействие с решателями.........................................................94
6.1. Введение................................................................................................................94
6.2. Использование решателей. ................................................................................95
6.3. Исследование решения.......................................................................................97
6.3.1. Результаты решателя. ..................................................................................97

Часть II. ДОПОЛНИТЕЛЬНЫЕ ТЕМЫ ...........................................................99
Глава 7. Нелинейное программирование в Pyomo. ..................................100
7.1. Введение..............................................................................................................100
7.2. Задачи нелинейного программирования в Pyomo.......................................101
7.2.1. Нелинейные выражения............................................................................101
7.2.2. Задача Розенброка......................................................................................102
7.3. Решение задач нелинейного программирования.........................................104
7.3.1. Нелинейные решатели...............................................................................105
7.3.2. Дополнительные советы по нелинейному программированию.........105
Инициализация переменных.........................................................................105
Неопределенные вычисления........................................................................106
Сингулярности модели и масштабирование задачи..................................106
7.4. Примеры нелинейного программирования..................................................107
7.4.1. Инициализация переменных для мультимодальной функции...........107
7.4.2. Оптимальные квоты для неистощительной добычи оленей...............108
7.4.3. Оценка моделей инфекционных заболеваний.......................................112
7.4.4. Проектирование реактора.........................................................................115

Глава 8. Структурное моделирование с по­мощью блоков.....................119
8.1. Введение..............................................................................................................119
8.2. Блочные структуры............................................................................................121
8.3. Блоки как индексированные компоненты....................................................123
8.4. Правила конструирования внутри блоков.....................................................124
8.5. Извлечение значений из иерархических моделей.......................................125
8.6. Пример использования блоков: оптимальный многопериодный
размер партии...........................................................................................................126
8.6.1. Формулировка без блоков.........................................................................127
8.6.2. Формулировка с блоками..........................................................................129

Глава 9. Производительность: конструирование модели
и интерфейсы с решателями. ...........................................................................131
9.1. Выявление узких мест с по­мощью профилирования. .................................131
9.1.1. Хронометраж...............................................................................................133
9.1.2. TicTocTimer..................................................................................................133
Книги для программистов: https://t.me/booksforits

Содержание  9

9.1.3. Профилировщики.......................................................................................134
9.2. Повышение производительности конструирования моделис по­мощью
класса LinearExpression............................................................................................137
9.3. Многократное решение с применением хранимых решателей.................138
9.3.1. Когда использовать хранимый решатель...............................................138
9.3.2. Основы использования..............................................................................139
9.3.3. Работа с индексированными переменными и ограничениями..........141
9.3.4. Повышение производительности............................................................142
9.3.5. Пример.........................................................................................................142
9.4. Разреженные множества индексов.................................................................143

Глава 10. Абстрактные модели и их решение. ...........................................145
10.1. Общие сведения...............................................................................................145
10.1.1. Абстрактные и конкретные модели. .....................................................145
10.1.2. Абстрактная формулировка модели (H)................................................147
10.1.3. Абстрактная модель для задачи о расположении складов.................148
10.2. Команда pyomo.................................................................................................150
10.2.1. Подкоманда help.......................................................................................151
10.2.2. Подкоманда solve......................................................................................152
10.2.2.1. Задание объекта модели. .................................................................154
10.2.2.2. Выбор данных с по­мощью пространств имен..............................155
10.2.2.3. Настройка технологического процесса Pyomo.............................158
pyomo_preprocess..............................................................................................159
pyomo_create_model..........................................................................................159
pyomo_create_modeldata..................................................................................159
pyomo_print_model. ..........................................................................................159
pyomo_modify_instance. ...................................................................................160
pyomo_print_instance........................................................................................160
pyomo_save_instance.........................................................................................160
pyomo_print_results...........................................................................................160
pyomo_save_results............................................................................................161
pyomo_postprocess............................................................................................161
10.2.2.4. Настройка поведения решателя. ....................................................161
10.2.2.5. Анализ результатов решателя.........................................................162
10.2.2.6. Управление диагностической печатью..........................................162
10.2.3. Подкоманда convert. ................................................................................164
10.3. Команды данных для AbstractModel.............................................................165
10.3.1. Команда set................................................................................................166
10.3.1.1. Простые множества. .........................................................................166
10.3.1.2. Множество кортежей........................................................................167
10.3.1.3. Массивы множеств............................................................................168
10.3.2. Команда param..........................................................................................168
10.3.2.1. Одномерные параметрические данные........................................169
10.3.2.2. Многомерные параметрические данные......................................171
10.3.3. Команда include........................................................................................173
10.3.4. Пространства имен данных....................................................................173
Книги для программистов: https://t.me/booksforits

10  Содержание
10.4. Компоненты построения................................................................................174

Часть III. РАСШИРЕНИЯ МОДЕЛИРОВАНИЯ .........................................176
Глава 11. Обобщенное дизъюнктивное программирование. ...............177
11.1. Введение............................................................................................................177
11.2. Моделирование ОДП в Pyomo........................................................................180
11.3. Выражение логических ограничений...........................................................182
11.4. Решение моделей ОДП....................................................................................183
11.4.1. Преобразование типа «M большое».......................................................183
11.4.2. Оболочечное преобразование................................................................184
11.5. Смешанная задача с полунепрерывными переменными.........................185

Глава 12. Дифференциальные алгебраические уравнения. .................187
12.1. Введение............................................................................................................187
12.2. Компоненты моделирования ДАУ в Pyomo. ................................................188
12.3. Решения моделей Pyomo с ДАУ. ....................................................................190
12.3.1. Конечно-разностное преобразование...................................................191
12.3.2. Преобразование коллокации..................................................................192
12.4. Дополнительные возможности......................................................................193
12.4.1. Применение нескольких дискретизаций. ............................................193
12.4.2. Ограничение формы управляющих входов. ........................................194
12.4.3. Построение графиков. .............................................................................194

Глава 13. Математические программы с ограничениями
равновесия..............................................................................................................196
13.1. Введение............................................................................................................196
13.2. Моделирование условий равновесия............................................................197
13.2.1. Условия дополнительности.....................................................................197
13.2.2. Выражения дополнительности...............................................................198
13.2.3. Моделирование смешанных условий дополнительности..................198
13.3. Преобразования МПОР...................................................................................202
13.3.1. Преобразование standard_form...............................................................202
13.3.2. Преобразование simple_nonlinear..........................................................203
13.3.3. Преобразование simple_disjunction.......................................................203
13.3.4. Интерфейс с AMPL-решателями............................................................204
13.4. Интерфейсы с решателями и метарешатели...............................................205
13.4.1. Нелинейные переформулирования.......................................................205
13.4.2. Дизъюнктивные переформулирования................................................206
13.4.3. PATH и интерфейс с ASL-решателем.....................................................206
13.5. Обсуждение.......................................................................................................207

Приложение А. Краткое руководство по Python. ......................................208
A.1. Обзор...................................................................................................................208
A.2. Установка и выполнение Python.....................................................................209
A.3. Формат строки в Python...................................................................................210
Книги для программистов: https://t.me/booksforits

Содержание  11

A.4. Переменные и типы данных............................................................................211
A.5. Структуры данных.............................................................................................212
A.5.1. Строки..........................................................................................................212
A.5.2. Списки. ........................................................................................................212
A.5.3. Кортежи. ......................................................................................................213
A.5.4. Множества...................................................................................................214
A.5.5. Словари........................................................................................................214
A.6. Условные предложения. ...................................................................................214
A.7. Итерации и циклы.............................................................................................215
A.8. Генераторы и списковые включения. ............................................................216
A.9. Функции..............................................................................................................216
A.10. Объекты и классы............................................................................................218
A.11. Присваивание, copy и deepcopy.....................................................................219
A.11.1. Ссылки.......................................................................................................219
A.11.2. Копирование.............................................................................................220
A.12. Модули..............................................................................................................220
A.13. Ресурсы, посвященные Python......................................................................221

Литература. .............................................................................................................222
Предметный указатель. ......................................................................................225

Книги для программистов: https://t.me/booksforits

От издательства
Отзывы и пожелания
Мы всегда рады отзывам наших читателей. Расскажите нам, что вы ду­маете
об этой книге – что понравилось или, может быть, не понравилось. Отзывы
важны для нас, чтобы выпускать книги, которые будут для вас максимально
полезны.
Вы можете написать отзыв на нашем сайте www.dmkpress.com, зайдя на
страницу книги и оставив комментарий в разделе «Отзывы и рецензии».
Также можно послать письмо главному редактору по адресу dmkpress@gmail.
com; при этом укажите название книги в теме письма.
Если вы являетесь экспертом в какой-либо области и заинтересованы в написании новой книги, заполните форму на нашем сайте по адресу http://
dmkpress.com/authors/publish_book/ или напишите в издательство по адресу
dmkpress@gmail.com.

Список опечаток
Хотя мы приняли все возможные меры для того, чтобы обеспечить высокое качество наших текстов, ошибки все равно случаются. Если вы найдете
ошибку в одной из наших книг, мы будем очень благодарны, если вы сообщите о ней главному редактору по адресу dmkpress@gmail.com. Сделав это,
вы избавите других читателей от недопонимания и поможете нам улучшить
последующие издания этой книги.

Нарушение авторских прав
Пиратство в интернете по-прежнему остается насущной проблемой. Издательство «ДМК Пресс» очень серьезно относится к вопросам защиты авторских прав
и лицензирования. Если вы столкнетесь в интернете с незаконной публикацией
какой-либо из наших книг, пожалуйста, пришлите нам ссылку на интернет-ресурс, чтобы мы могли применить санкции.
Ссылку на подозрительные материалы можно прислать по адресу элект­
ронной почты dmkpress@gmail.com.
Мы высоко ценим любую помощь по защите наших авторов, благодаря
которой мы можем предоставлять вам качественные материалы.

Благодарности
Здесь будут фамилии тех, кто помогал изданию этой книги, прислав в издательство найденные ошибки или ссылку на подозрительные материалы.

Книги для программистов: https://t.me/booksforits

Предисловие
В этой книге описывается инструмент математического моделирования –
программа Python Optimization Modeling Objects (Pyomo). Pyomo поддерживает создание и анализ математических моделей для сложных приложений
оптимизации. Обычно эта способность ассоциируется с языками алгебраического моделирования (algebraic modeling languages – AML) высокого уровня.
Большинство AML реализованы как самостоятельные языки моделирования,
но объекты моделирования Pyomo встроены в Python, полноценный язык
программирования высокого уровня, для которого имеется обширный набор библиотек. Pyomo получил награды организации R&D100 и INFORMS
Computing Society.
Моделирование – фундаментальный процесс во многих аспектах научных исследований, техники и бизнеса, а благодаря широкому распространению вычислительной техники численный анализ математических моделей
стал обыденностью. Ко всему прочему основным принципом языков AML
стала робастная формулировка больших моделей для сложных приложений,
встречающихся на практике [37]. AML облегчили процесс формулирования
моделей, упростив управление разреженными данными и добавив поддержку естественного выражения компонентов модели. Дополнительно
AML типа Pyomo поддерживают написание скриптов, включающих объекты
модели, что дает возможность проводить нестандартный анализ сложных
задач.
Основой Pyomo является объектно ориентированное представление моделей оптимизации. Также Pyomo содержит пакеты для определения расширений и переформулирования модели. Кроме того, в состав Pyomo входят
пакеты, определяющие интерфейсы с такими решателями, как CPLEX и Gurobi, и службами решения типа NEOS.

Цели этой книги
В третье издание включено переработанное описание средства моделирования Pyomo. Основная цель книги – дать общее описание Pyomo, которое
позволило бы пользователям создавать и оптимизировать модели. Поэтому
в книге много примеров, иллюстрирующих различные методы формулирования моделей.
Другая цель книги – проиллюстрировать богатство возможностей Pyomo,
в том числе формулирование и анализ типичных моделей оптимизации,
включая линейное программирование, смешанно-целочисленное линейное
программирование, нелинейное программирование, смешанно-целочисленное нелинейное программирование, математическое программироваКниги для программистов: https://t.me/booksforits

14  Предисловие
ние с ограничениями равновесия, ограничения и целевые функции, основанные на дифференциальных уравнениях, обобщенное дизъюнктивное
программирование. Кроме того, Pyomo включает интерфейсы к различным
распространенным пакетам программ оптимизации, как то CBC, CPLEX,
GLPK и Gurobi. Модели Pyomo можно оптимизировать с по­мощью таких
программ, как IPOPT, в которой используется интерфейс к библиотеке AMPL
Solver Library.
Наконец, книга призвана облегчить знакомство с Pyomo даже тем пользователям, которые мало что знают о Python. Приложение A содержит краткое
введение в Python, но мы были поражены тем, насколько справочники по
Python полезны новым пользователям Pyomo. Хотя в Pyomo используются
объекты Python, выражение моделей на Pyomo следует ясному и лаконичному синтаксису Python.
Однако в нашем обсуждении продвинутых средств моделирования Pyomo
предполагается некоторое знакомство с объектно ориентированным проектированием и возможностями языка Python. Например, мы проводим различие между определением класса и его экземплярами. Мы не пытались
объяснить эти средства Python в книге. Поэтому от читателя ожидается желание хотя бы немного изучить Python, если он хочет понимать и эффективно
использовать продвинутые средства моделирования.

Для кого предназначена эта книга
Книга представляет собой справочное пособие для студентов, научных
работников и инженеров-практиков. Структура Pyomo настолько проста,
что программу можно использовать в курсах для студентов и аспирантов.
Однако предполагается, что читатель знаком с основами оптимизации
и математического моделирования. В книге нет глоссария, но мы рекомендуем использовать для справки глоссарий математического программирования [32].
Pyomo также является ценным инструментом для теоретиков и практиков. При разработке Pyomo много внимания было уделено способности поддерживать описание и анализ реальных приложений. А значит, производительность и надежные интерфейсы с решателями занимали не последнее
место.
Кроме того, мы надеемся, что исследователи найдут в Pyomo эффективный каркас для разработки высокоуровневых средств оптимизации и анализа. Например, Pyomo лежит в основе пакета оптимизации в условиях
неопределенности mpi-sppy, в котором используется тот факт, что объекты
моделирования встроены в полнофункциональный высокоуровневый язык
программирования. Это позволяет прозрачно распараллеливать подзадачи
с по­мощью соответствующих библиотек Python. Этот механизм разработки
обобщенных решателей для сложных моделей очень мощный, и мы надеемся, что его можно будет использовать в сочетании со многими другими
методами оптимизации.

Книги для программистов: https://t.me/booksforits

Предисловие  15

Благодарности
Мы ценим усилия многих людей, способствовавших выходу этого и предыдущих изданий книги. Мы благодарны Элизабет Лоев из издательства Springer,
которая сопровождала книгу от идеи до последних этапов производства; ее
энтузиазм заразителен. Мы также благодарим Маделинн Фарбер из Sandia
National Laboratories за помощь в юридических нюансах выпуска программного обеспечения с открытым исходным кодом и публикации книги. Наконец, мы признательны Дугу Проуту за разработку логотипов Pyomo, PySP,
Pyomo.DAE и Coopr.
Мы в долгу перед всеми, кто тратил свое время и силы на рецензирование книги. Не будь их, книга содержала бы много опечаток и программных
ошибок. Итак, спасибо Джеку Инголлу, Зеву Фридману, Харви Гринбергу,
Шону Леггу, Анжелике Вонг, Дэниэлю Уорду, Деанне Гарсиа, Эллис Озакиол
и Флориану Мадеру. Отдельное спасибо Эмбер Грей-Фенне и Рэнди Бросту.
Особенно мы благодарны растущему сообществу пользователей Pyomo.
Ваш интерес к Pyomo и ваш энтузиазм стали самым важным фактором, повлиявшим на наше решение написать эту книгу. Мы благодарим первых
приверженцев Pyomo, которые поделились с нами подробными отзывами
о структуре и полезности программы, в том числе Фернандо Бадилла, Стивена Чена, Неда Дмитрова. ЮэЮэ Фана, Эрика Хонга, Аллена Холдера, Андреса
Ироуме, Дэррила Меландера, Кэрол Мейерс, Пьера Нансель-Пенарда, Мехула
Рангвала, Еву Уормингхаус и Дэвида Алдерсона. Ваши отзывы продолжают
оказывать важное влияние на дизайн и возможности Pyomo.
Мы также благодарны нашим друзьям из проекта COIN-OR за поддержку
Pyomo. Хотя разработка Pyomo ведется в основном на GitHub, наше партнерство с COIN-OR – ключевая часть нашей стратегии, благодаря которой Pyomo
остается жизнеспособным проектом с открытым исходным кодом.
Особая благодарность – нашим коллегам, создававшим пакеты для Pyomo:
Франсиско Муньосу, Тимоти Эклу, Кэвину Хантеру, Патрику Стилу и Дэниэлю
Уорду. Мы также признательны Тому Браунстейну, Дэйву Гэю и Нику Беневидасу за помощь в разработке модулей Python документации по Pyomo.
Авторы выражают благодарность за поддержку, оказанную при создании этой книги: Национальному научному фонду (гранты CBET#0941313
и CBET#0955205), Управлению передовых научных исследований в области
вычислений при отделении по науке Министерства энергетики США, проекту ARPA-E Министерства энергетики США в рамках программы интеграции
зеленых электрических сетей, Институту проектирования передовых энергетических систем (IDAES) с финансированием от отдела технических систем
на основе имитационного моделирования, междисциплинарную исследовательскую программу отделения ископаемого топлива Министерства энергетики США, программу моделирования передовых сетей электроснабжения
(AGM) Министерства энергетики США и Лабораторию целенаправленных
исследований и разработок в Sandia National Laboratories.
И наконец, мы благодарны своим семьям и друзьям за их терпеливое отношение к нашей страсти к программам оптимизации.

Книги для программистов: https://t.me/booksforits

16  Предисловие

Замечания и вопросы
В этой книге документирована версия Pyomo 6.0. Дополнительную информацию, включая опечатки, смотрите на сайте Pyomo: http://www.pyomo.org.
Исходный код Pyomo размещен на GitHub, а примеры, приведенные в этой
книге, находятся в каталоге pyomo/examples/doc/pyomobook: https://github.com/
Pyomo/pyomo.
На многие вопросы, касающиеся Pyomo, есть ответы на сайте Stack Overflow: https://stackoverflow.com/.
Мы приветствуем отзывы читателей. Направляйте их непосредственно
авторам или на форум Pyomo: pyomo-forum@googlegroups.com.
Удачи!
Альбукерк, Нью-Мексико, США
Энн Арбор, Мичиган, США
Альбукерк, Нью-Мексико, США
Альбукерк, Нью-Мексико, США
Альбукерк, Нью-Мексико, США
Альбукерк, Нью-Мексико, США
Ливермор, Калифорния, США
Дэвис, Калифорния, США

Майкл Бинум
Гэйб Хакебейл
Уильям Харт
Карл Лэрд
Бетани Николсон
Джон Сиирола
Жан-Поль Уотсон
Дэвид Л. Вудраф
5 января 2021 г.

Книги для программистов: https://t.me/booksforits

Глава

1
Введение

В этой главе мы познакомимся с Pyomo, инструментом для моделирования
и решения задач оптимизации на основе Python, и расскажем, зачем он создавался. Моделирование – фундаментальный процесс во многих аспектах
научных исследований, техники и бизнеса. Языки алгебраического моделирования типа Pyomo – это высокоуровневые языки для формулирования
и решения математических задач оптимизации. Pyomo – гибкий и расширяемый каркас моделирования, который вбирает в себя и обобщает главные
идеи языков алгебраического моделирования, организуя их в контексте широко распространенного языка программирования.

1.1. Языки моделирования для оптимизации
В этой книге описывается инструмент математического моделирования:
программный пакет Python Optimization Modeling Objects (Pyomo). Pyomo
поддерживает формулирование и анализ математических моделей для сложных задач оптимизации. Обычно эта возможность ассоциируется с коммерческими языками алгебраического моделирования (AML), такими как AIMMS
[1], AMPL [2] и GAMS [22]. Pyomo реализует развитый набор средств моделирования и анализа и предоставляет доступ к этим средствам из полнофункционального высокоуровневого языка программирования Python, для
которого написано множество библиотек.
Модели оптимизации определяют целевые функции для рассматриваемой системы. Модели можно использовать для исследования компромиссов
между различными целевыми функциями, нахождения экстремальных состояний и худших случаев, а также идентификации основных факторов, от
которых зависит поведение системы. Поэтому модели оптимизации применяются для анализа широкого круга научных, деловых и технических задач.
Благодаря широкой доступности вычислительных ресурсов численный
анализ моделей оптимизации стал обыденным явлением. Для вычислительного анализа модели оптимизации необходимо описать модель и передать
ее программе-решателю. В отсутствие языка спецификации таких моделей
процесс написания входных файлов, выполнения решателя и получения реКниги для программистов: https://t.me/booksforits

18  Введение
зультатов от него оказывается утомительным и чреват ошибками. На это
накладывается тот факт, что реальные приложения велики и сложны, так
что отлаживать их трудно. Ко всему прочему для решателей имеется много
разных форматов ввода, но лишь малая их часть стандартизирована. Таким образом, применение нескольких решателей для анализа одной модели оптимизации влечет за собой дополнительные сложности. Кроме того,
верифицировать модель (т. е. проверить, что переданная решателю модель
точно выражает намерения разработчика) исключительно трудно, не имея
высокоуровневого языка для выражения модели.
AML – это высокоуровневые языки для описания и решения задач оптимизации [26, 37]. Они сводят к минимуму трудности, связанные с анализом
моделей, благодаря высокоуровневой спецификации модели. Кроме того,
AML предоставляют интерфейсы к внешним программам-решателям, которые используются для анализа задач, и позволяют пользователю взаимодействовать с результатами решателя в контексте этой спецификации.
Специализированные AML, такие как AIMMS [1], AMPL [2, 21] и GAMS
[22], представляют собой языки описания модели оптимизации с интуитивно понятным и лаконичным синтаксисом для определения переменных, ограничений и целевых функций. Кроме того, они поддерживают
абстрактные понятия: разреженные множества, индексы и алгебраические
выражения, без которых не обойтись при описании крупномасштабных
реальных задач с тысячами или миллионами ограничений и переменных.
Эти AML могут представлять самые разные модели оптимизации и реализуют интерфейсы с различными решателями. В последнее время AML
стали поддерживать новые скриптовые возможности, которые позволяют
выражать высокоуровневые алгоритмы анализа вместе со спецификацией
модели оптимизации.
Альтернативная стратегия – использовать AML, который расширяет какойнибудь стандартный высокоуровневый язык программирования (в противоположность специализированному проприетарному языку) для формулирования моделей оптимизации, которые затем анализируются решателями,
написанными на низкоуровневых языках. Такой двухъязыковой подход сочетает гибкость высокоуровневого языка для формулирования задач оптимизации и эффективность низкоуровневого для численных расчетов. Этот
подход завоевывает все большую популярность в программном обеспечении
для научных расчетов. Среда оптимизации TOMLAB, написанная на Matlab [57], – один из наиболее зрелых пакетов, в которых он применяется;
в Pyomo также используется этот подход. Есть еще примеры расширения
стандартных языков программирования типа Java и C++ путем включения
AML-конструкций. Так, библиотеки моделирования FlopC++ [19], OptimJ [47]
и JuMP [13] поддерживают описание моделей оптимизации с использованием объектно ориентированного проектирования на C++, Java и Julia соответственно. Эти библиотеки частично приносят в жертву интуитивно понятный математический синтаксис специализированного AML, зато позволяют
воспользоваться всей гибкостью современных языков программирования
высокого уровня. Их дополнительное преимущество заключается в том, что
они непосредственно компонуются с высокопроизводительными библиоКниги для программистов: https://t.me/booksforits

Моделирование на Pyomo  19

теками оптимизации и решателями, что для некоторых приложений может
быть существенно.

1.2. Моделирование на Pyomo
Цель Pyomo – предоставить платформу для описания моделей оптимизации,
которая воплощает идеи современных AML в контексте, обеспечивающем
гибкость, расширяемость, переносимость, открытость и удобство сопровождения. Pyomo – это AML, расширяющий Python путем включения объектов
для моделирования оптимизации [30]. Эти объекты можно использовать для
задания моделей оптимизации и их преобразования в различные форматы,
понятные внешним решателям.
Теперь мы приведем несколько примеров, иллюстрирующих использование Pyomo для описания моделей оптимизации.

1.2.1. Простые примеры
Рассмотрим следующую линейную программу (ЛП):
min x1 + 2x2
при условиях 3x1 + 4x2 ≥ 1
2x1 + 5x2 ≥ 2
x1, x2 ≥ 0
Эту ЛП легко выразить на Pyomo следующим образом:
import pyomo.environ as pyo
model = pyo.ConcreteModel()
model.x_1 = pyo.Var(within=pyo.NonNegativeReals)
model.x_2 = pyo.Var(within=pyo.NonNegativeReals)
model.obj = pyo.Objective(expr=model.x_1 + 2*model.x_2)
model.con1 = pyo.Constraint(expr=3*model.x_1 + 4*model.x_2 >= 1)
model.con2 = pyo.Constraint(expr=2*model.x_1 + 5*model.x_2 >= 2)

Первая строка – стандартное предложение импорта в Python, которое
инициализирует окружение Pyomo и загружает библиотеку базовых компонентов моделирования. В следующей строке конструируется объект модели и определяются его атрибуты. В этом примере описывается конкретная
модель. Компоненты модели – объекты, являющиеся атрибутами объекта
модели, а объект ConcreteModel инициализирует каждый компонент модели
при добавлении. Переменные, ограничения и целевая функция модели определяются с по­мощью компонентов модели.
Редко бывает так, что создается единственный экземпляр некоторой модели оптимизации, подлежащей решению. Чаще имеется общая модель оп-

Книги для программистов: https://t.me/booksforits

20  Введение
тимизации, а затем создается конкретный экземпляр этой модели с определенными данными. Например, следующие уравнения представляют ЛП со
скалярными параметрами n и m, векторными параметрами b и c и матричным параметром a:

åni=1cixi
при условиях åni=1ajixi ≥ bj
min

xi ≥ 0

∀j = 1…m
∀i = 1…n

Эту ЛП можно выразить в виде конкретной модели на Pyomo следующим
образом:
import pyomo.environ as pyo
import mydata
model = pyo.ConcreteModel()
model.x = pyo.Var(mydata.N, within=pyo.NonNegativeReals)
def obj_rule(model):
return sum(mydata.c[i]*model.x[i] for i in mydata.N)
model.obj = pyo.Objective(rule=obj_rule)
def con_rule(model, m):
return sum(mydata.a[m,i]*model.x[i] for i in mydata.N) \
>= mydata.b[m]
model.con = pyo.Constraint(mydata.M, rule=con_rule)

Этот скрипт требует, чтобы при конструировании каждого компонента модели были доступны соответствующие данные. В нашем случае необходимые
данные находятся в файле mydata.py:
N
M
c
a
b

=
=
=
=
=

[1,2]
[1,2]
{1:1, 2:2}
{(1,1):3, (1,2):4, (2,1):2, (2,2):5}
{1:1, 2:2}

Эту ЛП можно также рассматривать как абстрактную математическую
модель, в которой неспецифицированные символические значения параметров определяются позже, на этапе инициализации модели. Например,
эту ЛП можно следующим образом выразить в виде абстрактной модели на
Pyomo:
import pyomo.environ as pyo
model = pyo.AbstractModel()
model.N = pyo.Set()
model.M = pyo.Set()

Книги для программистов: https://t.me/booksforits

Моделирование на Pyomo  21
model.c
model.a
model.b
model.x

=
=
=
=

pyo.Param(model.N)
pyo.Param(model.M, model.N)
pyo.Param(model.M)
pyo.Var(model.N, within=pyo.NonNegativeReals)

def obj_rule(model):
return sum(model.c[i]*model.x[i] for i in model.N)
model.obj = pyo.Objective(rule=obj_rule)
def con_rule(model, m):
return sum(model.a[m,i]*model.x[i] for i in model.N) \
>= model.b[m]
model.con = pyo.Constraint(model.M, rule=con_rule)

Этот пример включает компоненты модели, которые предоставляют абстрактные, или символические, определения множества и значений параметров. Объект AbstractModel откладывает инициализацию компонентов модели до момента создания экземпляра модели, когда передаются заданные
пользователем данные множества и параметры. И конкретные, и абстрактные модели можно инициализировать данными из различных источников,
включая файлы команд данных, например:
param : N : c :=
1 1
2 2 ;
param : M : b :=
1 1
2 2 ;
param a :=
1 1 3
1 2 4
2 1 2
2 2 5 ;

1.2.2. Пример раскраски графа
Мы продолжим иллюстрировать возможности моделирования Pyomo на примере простой хорошо известной задачи оптимизации: минимальной раскраски графа (известной также как раскраска вершин). В задаче о раскраске
графа требуется назначить цвета вершинам графа, так чтобы никакие две
смежные вершины не были окрашены в один цвет. У раскраски графов есть
много практических применений, включая распределение регистров в компиляторах, планирование ресурсов и сопоставление с образцами, а кроме
того, она лежит в основе развлекательных головоломок типа судоку.
Обозначим G = (V, E) граф с множеством вершин V и множеством ребер
E ⊆ V ×V. Для данного G целью в задаче минимальной раскраски графа является нахождение допустимой раскраски минимальным числом цветов. Для

Книги для программистов: https://t.me/booksforits

22  Введение
простоты предположим, что ребра из множества E упорядочены таким образом, что если (v1, v2) ∊ E, то v1 < v2. Обозначим k максимальное число цветов
и определим множество возможных цветов C = {1, …, k}.
Задачу минимальной раскраски графа можно представить в виде следующей целочисленной программы (ЦП):
min y
при условиях åc∊C xv,c = 1
xv1,c + xv1,c ≤ 1
y ≥ c · xv,c
xv,c ∊ {0, 1}

∀v ∊ V
∀(v1, v2) ∊ E
∀v ∊ V, c ∊ C
∀v ∊ V, c ∊ C

(1.1)

В этой формулировке переменная xv,c равна 1, если вершина v окрашена
цветом c, и 0 в противном случае, а y – число использованных цветов. Первое
ограничение требует, чтобы каждая вершина была окрашена ровно одним
цветом. Второе ограничение означает, что вершины, соединенные ребром,
должны быть окрашены разными цветами. Третье ограничение определяет
нижнюю границу y и гарантирует, что y не меньше числа цветов, использованных для раскраски. Четвертое, и последнее, ограничение означает, что xv,c
могут принимать только два значения.
На рис. 1.1 приведена формулировка описанной задачи раскраски графа в Pyomo с использованием конкретной модели; пример взят из работы
Gross and Yellen [27]. Эта спецификация состоит из предложений Python,
определяющих объект ConcreteModel, и последующего определения различных атрибутов этого объекта, включая переменные, ограничения и целевую
функцию оптимизации. В строках 10–24 определены данные модели. Строка 28 – стандартное предложение импорта Python, которое вносит все символы (например, классы и функции), определенные в pyomo.environ, в текущее
пространство имен. В строке 31 создается объект модели – экземпляр класса
ConcreteModel. В строках 34 и 35 определены переменные модели. Отметим,
что y – скалярная переменная, а x – двумерный массив переменных. В остальных строках определяются ограничения и целевая функция модели. Класс
Objective определяет единственную целевую функцию с по­мощью именованного параметра expr. Класс ConstraintList представляет список ограничений,
которые добавляются по одному.
По сравнению со специализированными AML, модели Pyomo, очевидно,
более многословны (см., например, Hart et al. [30]). Однако этот пример иллюстрирует, что синтаксис Python все же позволяет выразить математические идеи лаконично и интуитивно понятно. Оставляя в стороне классы
Pyomo, в этом примере нет ничего, кроме стандартного синтаксиса и методов Python. Например, в строке 4 используются генераторы Python для
обхода всех элементов множества colors и применения к ним функции sum.
В Pyomo имеются некоторые служебные функции, позволяющие упростить
конструирование выражений, но никаких хитроумныхрасширений базовой
функциональности Python не требуется.

Книги для программистов: https://t.me/booksforits

Моделирование на Pyomo  23
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#
#
#
#
#
#
#

Пример раскраски графа, написанный на основе программы из книги
Jonathan L. Gross and Jay Yellen,
"Graph Theory and Its Applications, 2nd Edition",
Chapman & Hall/CRC, Boca Raon, FL, 2006.

# Определить данные графа
vertices = set (['Ar', 'Bo', 'Br', 'Ch', 'Co', 'Ec',
'FG', 'Gu', 'Pa', 'Pe', 'Su', 'Ur', 'Ve'])
edges = set ([('FG',
('Su',
('Ve',
('Co',
('Pe',
('Ch',
('Ar',
('Ur',
('Pa',

'Su'), ('FG',
'Br'), ('Gu',
'Co'), ('Ve',
'Pe'), ('Co',
'Ch'), ('Pe',
'Ar'), ('Ch',
'Br'), ('Ar',
'Br'), ('Bo',
'Br')])

'Br'),
'Ve'),
'Br'),
'Br'),
'Bo'),
'Bo'),
'Pa'),
'Pa'),

('Su',
('Gu',
('Co',
('Ec',
('Pe',
('Ar',
('Ar',
('Bo',

'Gu'),
'Br'),
'Ec'),
'Pe'),
'Br'),
'Ur'),
'Bo'),
'Br'),

ncolors = 4
colors = range(1, ncolors+1)
# Предложение импорта Python
import pyomo.environ as pyo
# Создать объект модели Pyomo
model = pyo.ConcreteModel()
# Определить переменные модели
model.x = pyo.Var(vertices, colors, within=pyo.Binary)
model.y=pyo.Var()
# Каждая вершина окрашивается одним цветом
model.nodecoloring = pyo.ConstraintList()
for v in vertices:
model.node_coloring.add(
sum(model.x[v,c] for c in colors) == 1)
# Вершины, соединенные ребром, нельзя окрашивать одним цветом
model.edge_coloring = pyo.ConstraintList()
for v,w in edges:
for c in colors:
model.edge_coloring.add(
model.x[v,c] + model.x[w,c] =c_model.x[v,c])
# Минимизировать число потребных цветов
model.obj = pyo.Objective(expr=model.y)

Рис. 1.1  Конкретная модель Pyomo
для задачи минимальной раскраски графа

Книги для программистов: https://t.me/booksforits

24  Введение

1.2.3. Ключевые особенности Pyomo
Python
Понятный синтаксис Python позволяет Pyomo выражать математические
идеи интуитивно понятно и лаконично. Кроме того, выразительные средства
программирования Python можно использовать для формулирования сложных моделей и определения высокоуровневых решателей, обращающихся
к высокопроизводительным библиотекам оптимизации. Python предоставляет развитые возможности написания скриптов и позволяет пользователям
анализировать модели и решения Pyomo, привлекая весь потенциал сторонних библиотек (например, numpy, scipy и matplotlib). Наконец, поскольку
Pyomo погружена в Python, пользователи могут изучать ее базовый синтаксис, пользуясь обширной документацией по Python.

Настраиваемые возможности
Pyomo спроектирована с учетом модели разработки по принципу «каши из
топора», когда каждый разработчик делает то, что ему хочется. Ключевым
элементом такого дизайна является каркас на основе плагинов, который
Pyomo использует для интегрирования компонентов модели, преобразований модели, решателей и диспетчеров решателей. Каркас управляет регист­
рацией этих возможностей. Таким образом, пользователи могут настраивать
Pyomo модульным образом, не опасаясь дестабилизировать базовую функциональность.

Командные инструменты и скрипты
Модели Pyomo можно анализировать с по­мощью командных утилит или
скриптов на Python. Командная утилита pyomo предоставляет обобщенный
интерфейс к большинству возможностей моделирования Pyomo и реализует
обобщенный процесс оптимизации. Этот процесс можно легко реализовать
Python-скриптом и настроить под конкретные потребности пользователя.

Определение конкретных и абстрактных моделей
Примеры в разделе 1.2.1 иллюстрируют поддержку конкретных и абстрактных моделей Pyomo. Разница между этими подходами к моделированию
заключается в том, когда именно инициализируются компоненты модели:
в конкретных моделях компоненты инициализируются сразу, а в абстрактных инициализация откладывается до момента инициализации модели.
Следовательно, оба подхода эквивалентны, а выбор зависит от контекста,
в котором используется Pyomo, и от вкусов пользователя. Модели обоих типов легко инициализировать данными из самых разных источников (например, файлов в форматах csv, json, yaml, excel и баз данных).

Книги для программистов: https://t.me/booksforits

Моделирование на Pyomo  25

Объектно ориентированный дизайн
В Pyomo применяется объектно ориентированный подход к проектированию
библиотек. Модель – это объект Python, а компоненты модели – атрибуты этого объекта. Такой дизайн позволяет Pyomo автоматически управлять
именованием компонентов модели и естественно разделяет компоненты
объектов разных моделей. Структуру моделей Pyomo можно уточнять с по­
мощью блоков, т. е. поддерживается иерархическая вложенность компонентов модели. Многие продвинутые средства моделирования Pyomo основаны
на таком структурном моделировании.

Выразительные возможности моделирования
Компоненты моделей Pyomo можно использовать для формулирования широкого круга задач оптимизации, в том числе:
  линейные программы;
  квадратичные программы;
  нелинейные программы;
  смешанно-целочисленные линейные программы;
  смешанно-целочисленные квадратичные программы;
  обобщенные дизъюнктивные программы;
  смешанно-целочисленные стохастические программы;
  динамические задачи с дифференциальными алгебраическими уравнениями;
  математические программы с ограничениями равновесия.

Интеграция с решателями
Pyomo поддерживает тесно и слабо связанные интерфейсы с решателями.
Тесно связанные инструменты моделирования обращаются к библиотечным
решателям задач оптимизации непосредственно (например, путем статической или динамической компоновки), а слабо связанные вызывают внешние
исполняемые файлы (например, посредством системных вызовов). Многие
решатели задач оптимизации читают данные задач в хорошо известных форматах (например, в формате AMPL nl [24]); они слабо связаны с Pyomo. Решатели, имеющие интерфейсы к Python (например, Gurobi и CPLEX), могут быть
тесно связаны, что позволяет избежать записи данных во внешние файлы.

Открытый исходный код
Pyomo разрабатывается как проект с открытым исходным кодом, чтобы сделать процесс проектирования и реализации ПО максимально прозрачным.
Pyomo распространяется на условиях лицензии BSD [8], которая налагает
меньше ограничений на использование в коммерческих или государственных организациях. Управление исходным кодом Pyomo осуществляется с по­

Книги для программистов: https://t.me/booksforits

26  Введение
мощью GitHub [53] и проекта COIN-OR [9]. Списки рассылки для разработчиков и пользователей ведутся с по­мощью Google Groups. Растет количество
свидетельств в пользу того, что надежность ПО с открытым исходным кодом
не уступает надежности закрытого коммерческого ПО [3, 59], и при разработке Pyomo ведется тщательный контроль для обеспечения стабильности
и надежности программы.

1.3. Подготовительные действия
Для выполнения примеров, приведенных в книге, необходимо установить
следующее программное обеспечение:
  Python версии 3.6 или старше (хотя почти все примеры работают и с более ранними версиями Python). В настоящее время Pyomo опирается
на CPython; для Jython и PyPy поддерживается лишь часть функциональности;
  Pyomo 6.0, именно эта версия используется в книге;
  решатель GLPK [25], который используется для генерирования вывода
большинства примеров. Можно использовать и другие решатели для
задач линейного и смешанно-целочисленного линейного программирования, но GLPK легко устанавливается и широко доступен;
  решатель IPOPT [34], который используется для генерирования вывода
в примерах нелинейных моделей. Можно использовать и другие нелинейные оптимизаторы, если они собраны с библиотекой AMPL Solver
Library [23];
  решатель CPLEX [11], который используется для генерирования вывода
в примерах стохастического программирования. Этот коммерческий
решатель предоставляет возможности, которые отсутствуют в решателях задач оптимизации с открытым исходным кодом (например,
оптимизацию квадратичных целочисленных программ);
  Python-пакет matplotlib для построения графиков.
Инструкции по установке Pyomo имеются на сайте Pyomo по адресу www.
pyomo.org. В приложении A приведено краткое пособие по языку программирования Python; в различных онлайновых источниках можно найти более
полные пособия и документацию.

1.4. Краткий обзор книги
Оставшийся текст книги разделен на три части. Первая часть – введение
в Pyomo. Главу 2 можно рассматривать как очень краткий курс оптимизации и математического моделирования, включающий примеры применения
Pyomo к формулированию и решению алгебраических моделей оптимизации. Глава 3 иллюстрирует возможности моделирования Pyomo на примере

Книги для программистов: https://t.me/booksforits

Обсуждение  27

простых конкретных и абстрактных моделей, а в главе 4 описываются базовые компоненты моделирования Pyomo. Основы вложения моделей Pyomo
в скрипты на Python излагаются в главе 5. И завершается первая часть главой 6, в которой описывается взаимодействие с решателями.
Во второй части книги документированы продвинутые возможности и расширения. В главе 7 описываются средства нелинейного программирования
Pyomo, а в главе 8 – построение иерархических моделей. Глава 9 содержит
рекомендации по повышению производительности. В главе 10 описан класс
AbstractModel, синтаксис командных файлов данных и командный интерфейс
к Pyomo.
Третья часть книги посвящена расширениям моделирования. В главе 11
приведен обзор обобщенного дизъюнктивного программирования. В главе 12 описаны динамические модели, выражаемые дифференциальными
и алгебраическими уравнениями, а в главе 13 – программы с ограничениями
равновесия.
ПРИМЕЧАНИЕ Эта книга не является полным справочным руководством по Pyomo.
Наша цель – обсудить базовую функциональность, имеющуюся в версии Pyomo 6.0.

1.5. Обсуждение
Многие разработчики пришли к выводу, что понятный синтаксис Python
и богатый набор библиотек – отличная почва для моделирования оптимизации [30]. Средства моделирования реализованы в различных пакетах программ на Python, например PuLP [49], APLEpy [4] и OpenOpt [46]. Кроме того,
существует немало пакетов, реализующих интерфейсы с решателями, в т. ч.
такие пакеты с открытым исходным кодом, как PyGlpk [50] и pyipopt [51],
в дополнение к Python-интерфейсам таких коммерческих решателей, как
CPLEX [11] и Gurobi [28].
У Pyomo есть несколько отличительных особенностей. Во-первых, Pyomo
предоставляет механизмы для расширения базовой функциональности моделирования и оптимизации без внесения изменений в код самой Pyomo.
Во-вторых, Pyomo поддерживает определение конкретных и абстрактных
моделей. Это дает пользователю большую гибкость при решении вопроса
о том, насколько тесно данные должны быть интегрированы с определением
модели. Наконец, Pyomo поддерживает широкий класс моделей оптимизации, включая стандартные линейные программы, общие нелинейные модели, обобщенные дизъюнктивные программы, задачи, описываемые дифференциальными уравнениями, и математические программы с условиями
равновесия.

Книги для программистов: https://t.me/booksforits

Часть

I

ВВЕДЕНИЕ В PYOMO

Книги для программистов: https://t.me/booksforits

Глава

2
Математическое
моделирование
и оптимизация

В этой главе объясняются начала оптимизации и математического моделирования. Вы не найдете здесь полного описания этих тем, а лишь информацию, необходимую для чтения книги. Более подробное обсуждение методов
оптимизации см. в работе Williams [58]. Приведены реализации простых
моделей, чтобы читатель получил первое представление о том, как используется Pyomo.

2.1. Математическое моделирование
2.1.1. Общие сведения
Моделирование – фундаментальный процесс во многих аспектах научных
исследований, техники и бизнеса. Под моделированием понимается создание упрощенного представления системы или объекта материального мира.
Такое упрощение позволяет структурировать знания об исходной системе,
чтобы проанализировать результирующую модель. Шихль (Schichl [56]) отмечает, что модели используются для следующих целей:
  объяснить явления, возникающие в системе;
  предсказать будущие состояния системы;
  оценить ключевые факторы, влияющие на происходящее в системе;
  идентифицировать экстремальные состояния системы, возможно,
представляющие худшие случаи или планы с минимальной стоимостью;
  проанализировать компромиссы и предложить их лицам, прини­
мающим решения.

Книги для программистов: https://t.me/booksforits

30  Математическое моделирование и оптимизация
Кроме того, структура представления модели упрощает передачу ассоциированных с моделью знаний. Например, одним из ключевых аспектов
модели является уровень детализации, который отражает знания о системе,
необходимые для использования модели в приложении.
Математика всегда играла важнейшую роль в представлении и формулировании наших знаний. Математическое моделирование становилось все более формальным по мере разработки новых каркасов для описания сложных
систем. В современном моделировании центральными являются следующие
математические понятия:
  переменные: представляют неизвестные или изменяющиеся части
модели (например, принимаемые решения или характеристики выхода системы);
  параметры: символические представления реальных данных, могут
варьироваться для различных экземпляров задачи или сценариев;
  отношения: равенства, неравенства и другие математические связи,
описывающие, как различные части модели соотносятся между собой.
Модели оптимизации – это математические модели, в которых функции
представляют цели, ради достижения которых моделируется система. Модели оптимизации можно анализировать, исследуя различные компромиссы, позволяющие находить решения, оптимизирующие целевые функции
системы. Следовательно, эти модели можно использовать в разнообразных
научных, технических и деловых приложениях.

2.1.2. Пример моделирования
Модель в том смысле, в котором мы употребляем это слово, представляет
объекты, абстрагируя некоторые свойства. Все мы знакомы с физическими
моделями, например игрушечными железными дорогами или моделями автомобилей. Но нас интересуют математические модели, в которых для представления аспектов системы или объекта материального мира используются
символы.
Например, человеку интересно определить, сколько шариков мороженого
лучше всего купить. Обозначим символом x число шариков, а символом c –
цену одного шарика. Тогда полную стоимость можно смоделировать как произведение c на x, обычно обозначаемое cx.
Может понадобиться более сложная модель, если имеются скидки за объем
заказа или наценки за неполные шарики. Скорее всего, эта модель не годится
для отрицательных x. Редко удается продать шарик мороженого за ту же цену,
за которую купил.
Труднее математически смоделировать счастье от покупки шариков мороженого в вафельном рожке. Один из возможных подходов – измерять счастье
пропорционально. Определим единицу счастья, ассоциированную с одним
шариком, и обозначим ее h. Тогда можно смоделировать счастье от покупки
x шариков как произведение h на x, или hx. Для кого-то такая модель является
неплохим приближением для значений x от ½ до 3, но вряд ли кто-то станет

Книги для программистов: https://t.me/booksforits

Математическое моделирование  31

в сто раз счастливее, получив в рожке 100 шариков мороженого, когда ему
достаточно одного. Для некоторых людей модель счастья для значений x от
0 до 10 может выглядеть так:
h · (x − (x/5)2).
Заметим, что в этой модели счастье становится отрицательным, когда
в рожке больше 25 шариков, поэтому не для всех она хороша.
Обычно хотят моделировать сразу несколько вещей. Например, к шарикам
мороженого могут прилагаться орешки. Поскольку можно купить несколько
вкусностей, купленное представляется вектором x (т. е. символ x теперь представляет список). Элементы списка обозначаются xi, где i – индекс элемента.
Например, если мы примем, что первый элемент – число шариков мороженого, то на это число можно ссылаться с по­мощью x1. При большем числе измерений в качестве индекса используется кортеж, обозначаемый i, j или (i, j).
Пусть c – вектор цен с такими же индексами, как у x (т. е. c1 – цена одного
шарика мороженого, а c2 – цена одной порции орешков). Тогда полная стоимость мороженого и орешков равна
c1 x1 + c2 x2 = å2i=1ci xi.
И эта модель стоимости, вероятно, годится не для всех возможных значений элементов x, но для каких-то целей она достаточно хороша.
Часто бывает полезно брать индексы из некоторого множества. Для рассмотренного выше примера можно было бы взять множество {1, 2} и записать
полную стоимость в виде

åi∊{1,2}ci xi,
но обычно используется более абстрактное выражение вида

åi∊𝒜 ci xi,
где под 𝒜 понимается множество индексов элементов векторов c и x (в нашем
примере 𝒜 будет равно {1, 2}).
Помимо суммирования по множеству индексов, нам иногда нужны условия, выполняющиеся для всех индексов. В этом случае используется запятая.
Например, если мы хотим, чтобы никакой элемент x не был отрицательным
числом, то можем написать:
xi ≥ 0, i ∊ 𝒜

– это читается как «x i-е больше либо равно нулю для всех i, принадлежащих 𝒜».
Ни в математике, ни в математическом моделировании нет такого закона, чтобы использовать только однобуквенные символы, например x, c
или i. Никто не запрещает в качестве элементов 𝒜 использовать изображения
рожка мороженого и чашки орешков, но работать с такими обозначениями
было бы трудно. Множество может быть и таким: {Scoops, Cups}, но в книгах

Книги для программистов: https://t.me/booksforits

32  Математическое моделирование и оптимизация
так обычно не делается, потому что занимает слишком много места и пришлось бы переносить строки. Точно так же x можно было бы заменить словом
Quantity или чем-то подобным. Длинные имена поддерживаются таким языками моделирования, как Pyomo, и, вообще говоря, использовать в моделях
осмысленные имена – здравая мысль. Пробелы или знаки минуса в именах
часто приводят к проблемам и путанице, поэтому обычно вместо них используются знаки подчеркивания.

2.2. Оптимизация
Символ x часто применяется как переменная при моделировании оптимизации. Иногда он называется переменной решения, потому что модели оптимизации и строятся для того, чтобы принимать решения. Это может запутать
людей, знакомых со статистическим моделированием. Там символ x часто
используется для обозначения данных, и компьютеру передаются значения
x, чтобы он вычислил статистики, тогда как в моделях оптимизации компьютеру передаются другие данные, а требуется вычислить хорошие значения x.
Конечно, никто не заставляет использовать именно букву x, но в учебниках
и вводных курсах обычно выбирают ее.
Такие значения, как стоимость (мы обозначали ее символом c), называются данными, или параметрами. Модель оптимизации можно описать, не
определяя значений параметров, но в конкретном оптимизируемом экземпляре значения данных должны быть определены, иногда мы называем их
данными экземпляра.
Чтобы можно было произвести оптимизацию, в модели должна быть определена целевая функция. При оптимальных значениях переменных решения
получается наилучшее возможное значение целевой функции. Важно отметить, что мы говорим «оптимальные значения» (во множественном числе),
потому что часто бывает так, что наилучшее значение целевой функции достигается при нескольких наборах значений переменных. Эта функция обычно записывается в очень абстрактной форме, например f(x). Что понимать
под «наилучшим» значением – наибольшее или наименьшее, определяется
типом оптимизации: максимизация или минимизация.
Предположим, к примеру, что x – не вектор, а скаляр, равный числу шариков мороженого. Если воспользоваться описанной выше моделью счастья, то
f(x) ≡ h · (x − (x/5)2),

где h – данные. (На самом деле в этом конкретном примере значение h совершенно не важно для нахождения x, максимизирующего счастье.) Смоделированная нами задача оптимизации записывается в виде
max h · (x − (x/5)2),
но склонные к строгости авторы пишут так:
maxx h · (x − (x/5)2),
Книги для программистов: https://t.me/booksforits

Оптимизация  33

чтобы было понятно, что x – переменная решения. В данном случае сущест­
вует всего одно наилучшее значение x, которое можно найти методами численной оптимизации. Это значение оказывается дробным, т. е. придется
купить нецелое число шариков. Такую модель не назовешь полезной для
типичной лавки мороженого, где купить можно только целое неотрицательное число шариков. Чтобы включить это требование, мы добавим в модель
оптимизации ограничение:
maxx h · (x − (x/5)2)
при условии
x ∊ множеству целых неотрицательных чисел.

Предположим, что эта модель используется не в лавке, а дома, где мороженое подает родитель пользователя модели. Если родитель готов делить
шарики на части, но не подает больше двух шариков, то ограничение
x ∊ множеству целых неотрицательных чисел

следует заменить таким:
0 ≤ x ≤ 2.

Эта модель неидеальна, потому что не все дробные значения x осмыслены.
Чтобы проиллюстрировать рассмотренные до сих пор аспекты модели,
вернемся к нескольким продуктам, которые описываются множеством индексов 𝒜, так что x – вектор. Воспользуемся следующей моделью счастья для
продукта с индексом i:
hi · (xi − (xi /di)2),

где h и d – векторы данных с таким же множеством индексов, как у x. Пусть
далее c – вектор цен, а u – вектор максимальных количеств продуктов, которые можно приобрести. Предположим временно, что для любого продукта
купленное количество может быть дробным. И наконец, предположим, что
бюджет ограничен величиной b. Тогда задачу оптимизации можно записать
в виде:

åi∊𝒜 hi · (xi – (xi/di)2
при условии åi∊𝒜 ci xi ≤ b
maxx

(H)

0 ≤ xi ≤ ui, i ∊ 𝒜

Иногда последнее ограничение записывают в виде двух:

åi∊𝒜 hi · (xi – (xi/di)2
при условии åi∊𝒜 ci xi ≤ b
maxx

(H)

xi ≤ ui, i ∊ 𝒜
xi ≥ 0, i ∊ 𝒜
Книги для программистов: https://t.me/booksforits

34  Математическое моделирование и оптимизация
Принято помещать сокращенное имя модели в скобках в одной строке
с целевой функцией. Имя (P) очень распространенное, но мы использовали
(H) как сокращение от «happiness» (счастье). По имени (H) мы будем ссылаться на эту модель далее в данной главе, когда покажем, как реализовать
ее в Pyomo и решить.

2.3. Моделирование в Pyomo
Теперь рассмотрим различные стратегии формулирования и оптимизации
алгебраических моделей в Pyomo. Детальное объяснение моделей Pyomo мы
отложим до главы 3, а здесь приведем только примеры использования Pyomo
для модели (H).

2.3.1. Конкретная формулировка
Конкретная модель Pyomo инициализирует компоненты по мере их конструирования. Это позволяет использовать встроенные в Python структуры
данных при определении экземпляра модели. Существует много способов
реализовать нашу модель в виде конкретной модели Pyomo, и начнем мы
с использования списков и словарей Python.
ПРИМЕЧАНИЕ Понимая, что нам часто придется создавать экземпляры моделей
с разными данными, мы решили написать функцию, которая принимает требуемые
данные в качестве аргументов и возвращает модель Pyomo. При таком подходе мы
сможем повторно использовать общую модель Pyomo с разными данными.
import pyomo.environ as pyo
def IC_model(A, h, d, c, b, u):
model = pyo.ConcreteModel(name = "(H)")
def x_bounds(m, i):
return (0,u[i])
model.x = pyo.Var(A, bounds=x_bounds)
def z_rule(model):
return sum(h[i] * (model.x[i] - (model.x[i]/d[i])**2)
for i in A)
model.z = pyo.Objective(rule=z_rule, sense=pyo.maximize)
model.budgetconstr = pyo.Constraint(\
expr = sum(c[i]*model.x[i] for i in A)