). На примере игры в зайца и волков будет рассмотрен алгоритм «Минимакс» и алгоритм его оптимизации «Альфа-бета отсечение». Помимо текстового описания, статья содержит иллюстрации, таблицы, исходники, и готовую кроссплатформенную игру с открытым кодом, в которой вы сможете посоревноваться с интеллектуальным агентом.

Игра «Заяц и волки»

На шахматной доске есть 4 волка сверху (на черных клеточках), и 1 заяц снизу (на одной из черных). Заяц ходит первым. Ходить можно только на одну клеточку по диагонали, притом волки могут ходить только вниз, а заяц в любую сторону. Заяц побеждает, когда достиг одной из верхних клеточек, а волки, когда они окружили или прижали зайца (когда зайцу некуда ходить).

Перед продолжением чтения, рекомендую поиграть , так будет легче понимать.

Эвристика

В практическом инженерном понимании, метод минимакса опирается на эвристику , которую мы рассмотрим прежде, чем переходить к сути алгоритмов.

В контексте минимакса, эвристика нужна для оценки вероятности победы того или иного игрока, для какого-либо состояния. Задача состоит в том, чтобы построить эвристическую оценочную функцию , которая достаточно быстро и точно, в выбраной метрике, сможет указать оценку вероятности победы конкретного игрока для конкретного расположения фигур, не опираясь на то, каким образом игроки к этому состоянию пришли. В моем примере оценочная функция возвращает значения от 0 до 254, где 0 - победа зайца, 254 - победа волка, промежуточные значения - интерполяция двух вышеуказанных оценок. Оценка вероятности - не вероятность, и не обязана быть ограниченной, линейной, непрерывной.

Пример оценочной функции 1 . Чем заяц выше, тем больше у него шансов на победу. Такая эвристика эффективна с точки зрения быстродействия (О(1)), но совершенно не пригодна алгоритмически. «Высота» зайца коррелирует с вероятностью победы, но искажает основную цель зайца - победить. Эта оценочная функция говорит зайцу двигаться вверх, но при небольшой глубине расчета будет приводить к тому, что заяц двигается вверх, не взирая на преграды, и попадает в ловушки.

Пример оценочной функции 2 . Заяц тем вероятней победит, чем меньше ему нужно сделать ходов для победы, при замороженных волках. Это более громоздкий алгоритм со сложностью О(n), где n – количество клеточек. Расчет количества ходов сводится к поиску в ширину:



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

Код, выполняющий поиск в ширину, а точнее заполнение карты значениями равными “расстоянию” от зайца:

this->queue.enqueue(this->rabbitPosition); while (!this->queue.empty()) { QPoint pos = this->queue.dequeue(); for (int i = 0; i < 4; i++) if (canMove(pos + this->possibleMoves[i])) { QPoint n = pos + this->possibleMoves[i]; this->map = this->map + 1; this->queue.enqueue(n); } }
Результатом оценочной функции должно быть значение равное «расстоянию» до ближайшей верхней клеточки, либо 254, если дойти до них невозможно. Несмотря на недостатки, которые я опишу ниже, именно эта эвристика используется в игре.

Тем, кто будет смотреть исходники и разбираться - внимание! Архитектура приложения построена таким образом, чтобы оценочную функцию можно было переделать, не затрагивая другие части кода. Но, следует использовать ранее выбранную метрику, иначе алгоритмы не будут понимать показания функции оценки.

Минимакс

Введем некоторые понятия и обозначения:

• Состояние, оно же узел дерева решений - расположение фигур на доске.
• Терминальное состояние - состояние, с которого больше нет ходов (кто-то победил / ничья).
  
• Vi - i -ое состояние.
• Vik - k -ое состояние, к которому можно прийти за один ход из состояния Vi. В контексте дерева решений, это дочерний узел Vi.
• f(Vi) - расчетная оценка вероятности победы для состояния Vi.
• g(Vi) - эвристическая оценка вероятности победы для состояния Vi.

f(Vi) отличается от g(Vi) тем, что g(Vi) использует информацию только о Vi , а f(Vi) - также Vik и другие состояния, рекурсивно.

Метод разработан для решения проблемы о выборе хода с состояния Vi . Логично выбирать ход, для которого оценка вероятности будет максимально выгодной для игрока, который ходит. В нашей метрике, для волков - максимальная оценка, для зайцев минимальная. А оценка считается следующим образом:

• f(Vi) = g(Vi) , если Vi - терминальное состояние, либо достигнут предел глубины расчетов.
• f(Vi) = max(f(Vi1), f(Vi2)… f(Vik)) , если Vi - состояние, с которого ходит игрок с поиском максимальной оценки.
• f(Vi) = min(f(Vi1), f(Vi2)… f(Vik)) , если Vi - состояние, с которого ходит игрок с поиском минимальной оценки.

Метод опирается на здравый смысл. Мы ходим так, чтобы максимизировать оценку собственной победы P, но чтобы просчитывать хоть что-то, нам нужно знать, как будет ходить враг, а враг будет ходить так, чтобы максимизировать оценку своей победы (минимизировать оценку P). Другими словами, мы знаем как будет ходить враг, и таким образом можем строить оценки вероятностей. Самое время указать о том, что алгоритм является оптимальным, если у врага такая же оценочная функция, и он действует оптимально. В таком случае, интеллектуальность зависит от глубины просчета, и от качества оценочной функции.

Самое время привести пример:



На этом примере, игрок играет зайцем, а компьютер волками. После того как заяц походил, компьютер запускает алгоритм минимакса, на этом примере с глубиной 1. Что делает алгоритм? А кто его знает? Алгоритм перебирает все возможные ходы для волка, и для них получает оценку вероятности победы. Эта оценка, как мы уже говорили ранее, состоит из того же запуска алгоритма минимакса, но уже для других состояний, и уже с ходом другого игрока, и уже с минимизацией, вместо максимизации. Это уже будет второй уровень, последний для указанной глубины 1, от того и дальше алгоритм минимакса не запускается, а возвращает функцию эвристической оценки.

Этот пример будет легче понимать, если рассматривать его снизу. На втором уровне у нас состояния, для которых мы получаем эвристическую оценку (она записана числами). По второму уровню, первый получает свои оценки, соответственно выбрав минимальные значения из тех, что проверены на следующем уровне. Ну и нулевой уровень, выбирает максимальную оценку, из тех, что предоставлены ему первым уровнем.

Теперь, когда у нас есть все оценки, что делать? Радоваться. Нужно выбрать ход. Тут все очевидно, для волка выбирает ход тот, который показывает наибольшую оценку, для зайца тот, который показывает наименьшую. Но ведь оценки для разных ходов могут быть равны, и тогда в идеале нужно выбрать случайным образом, но тут начинаются нюансы. Сразу скажу, что у меня для волка берется первый ход из списка с максимальной оценкой, а для зайца – последний из списка с минимальной оценкой. И это печально, так как достаточно серьезная оптимизация опирается на то, что всегда будет выбираться первый ход из нужного списка. Но для зайца это совершенно не подходит. Дело в том, что волк очень часто (по мере возможностей) ходит так, чтобы оценка была равна бесконечности (254), что делает любой ход зайца “бессмысленным”, и если он будет выбирать любой ход – он будет ходить вниз, либо как попало, а нам нужно заставить его идти вверх, напролом, нарушая фронт волков. Правильно было бы сделать так, чтобы функция эвристики учитывала то, как высоко заяц находится, но с меньшим коэффициентом, чем основная эвристика, но я сделал не так, а как уже описал ранее. Потому и выбирается последний из списка ход, который указывает зайцу идти вверх.

Пример реализации алгоритма:
//возвращает оценку текущего состояния f(Vi) int Game::runMinMax(MonsterType monster, int recursiveLevel) { int test = NOT_INITIALIZED; //на последнем уровне дерева (на листах) возвращаем значение функции эвристики if (recursiveLevel >= this->AILevel * 2) return getHeuristicEvaluation(); //индекс выбранного пути. 0-7 - возможные ходы волков, 8-11 - возможные ходы зайца int bestMove = NOT_INITIALIZED; bool isWolf = (monster == MT_WOLF); int MinMax = isWolf ? MIN_VALUE: MAX_VALUE; //перебираем все возможные хода данного монстра for (int i = (isWolf ? 0: 8); i < (isWolf ? 8: 12); i++) { int curMonster = isWolf ? i / 2 + 1: 0; QPoint curMonsterPos = curMonster == 0 ? rabbit: wolfs; QPoint curMove = possibleMoves; if (canMove(curMonsterPos + curMove)) { //...ходим, после чего обрабатываем ситуацию temporaryMonsterMovement(curMonster, curMove); //оцениваем, насколько хорош ход, который мы выбрали test = runMinMax(isWolf ? MT_RABBIT: MT_WOLF, recursiveLevel + 1); //если он лучше всех, что были до этого - запомним, что он лучший if ((test > <= MinMax && monster == MT_RABBIT)) { MinMax = test; bestMove = i; } //... и восстанавливаем исходное состояние temporaryMonsterMovement(curMonster, -curMove); } } if (bestMove == NOT_INITIALIZED) return getHeuristicEvaluation(); //ну и собственно, ходим, коль уже выбрали лучший ход if (recursiveLevel == 0 && bestMove != NOT_INITIALIZED) { if (monster == MT_WOLF) wolfs += possibleMoves; else rabbit += possibleMoves; } return MinMax; }
Внимание! Тут переменная bestMove инкапсулирует много смысла (уточню при запросе), взываю вас никогда не вкладывать столько смысла в 4 бита, если вы не уверены в том, что вы делает все правильно.

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

Альфа-бета отсечение

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

Грубо говоря, оптимизация вводит две дополнительные переменные alpha и beta , где alpha - текущее максимальное значение, меньше которого игрок максимизации (волки) никогда не выберет, а beta - текущее минимальное значение, больше которого игрок минимазации (заяц) никогда не выберет. Изначально они устанавливаются в -∞, +∞ соответственно, и по мере получения оценок f(Vi) модифицируются:

• alpha = max(alpha, f(Vi)); для уровня максимизации.
• beta = min(beta, f(Vi)); для уровня минимизации.

Как только условие alpha > beta станет верным, что означает конфликт ожиданий, мы прерываем анализ Vik и возвращаем последнюю полученную оценку этого уровня.

На нашем примере, на втором рисунке, с помощью альфа-бета отсечений, полностью отсекаются 3 нижних ряда, но без самого левого столбца. Я считаю, что это не удачный пример для объяснения, а потому возьму пример из википедии, который чуть более удачный.



Обозначения в примере:

• Vi - узлы дерева поиска решений, i никоим образом не коррелирует с порядком обхода дерева.
• Vi - узлы с указанными текущими значениями alpha, beta.
• Ci - i-ое альфа-бета отсечение.
• MIN, MAX - уровни максимизации и минимазации соответственно. Будьте внимательны, состояния на уровне максимума будут выбирать свои максимумы из состояний следующего уровня, на которых указан MIN, и наоборот. То есть максимальный выбирается из тех, на которых написан MIN, а минимальный из тех, на которых написан MAX, не перепутайте.

Рассмотрим отсечение 1. После того, как для узла V1 был полностью обработан вариант с узлом V3, и получена его оценка f(V3) = 6, алгоритм уточняет значение alpha для этого узла (V1), и передает его значение в следующий узел - V4. Теперь для всех дочерних узлов V4 минимальный alpha = 6. После того как узел V4 обработал вариант с узлом V5, и получил оценку f(V5) = 5, алгоритм уточняет значение beta для узла V4. После обновления, для узла V4 мы получили ситуацию в которой alpha > beta, и следовательно другие варианты узла V4 рассматривать не нужно. И нам не важно, какая оценка будет у отсеченного узла:

• Если значение отсеченного узла меньше или равно 5 (beta), то в узел V4 будет выбрана оценка, которая не больше 5, и соответственно вариант с узлом V4 никогда не будет выбран узлом V1, потому что оценка узла V3 - лучше.
• Если значение отсеченного узла больше или равно 6 (beta + 1), то узел тем более не будет рассматриваться, поскольку узел V4 выберет вариант с узлом V5, так как его оценка меньше (лучше).

Отсечение 2 абсолютно идентично по структуре, и я бы рекомендовал вам попробовать разобрать его самостоятельно. Отсечение 3 намного интересней, внимание , пример на википедии явно в чем-то не прав. Он позволяет себе проводить отсечения, если (alpha >= beta), хотя альфа-бета должна была бы быть оптимизацией, и не влиять на выбор пути. Дело в том, что везде пишут, что отсечение должно срабатывать, когда alpha >= beta, хотя в общем случае, только когда alpha > beta.

Допустим, для некоторого дерева решений, все дети показывают одинаковую оценку. Тогда можно было бы выбрать из них любую, случайным образом, и это было бы правильно. Но у вас не получится так делать, используя условия alpha >= beta, потому что после первой оценки все остальные могут быть отсечены. Но это не беда, допустим, не будет ваш алгоритм реализовывать стохастическое поведение, это не так важно, но если в вашем алгоритме выбор лучшего из значений с одинаковой оценкой важен, то такое условие отсечения приведет к тому, что алгоритм просто поломается, и будет ходить не оптимально. Будьте бдительны!

Альфа-бета отсечение – очень простой для реализации алгоритм, и суть его сводится к тому, что в функцию минимакса нужно добавить 2 переменные alpha и beta в интерфейс процедуры минимакса, и небольшой кусок кода в ее тело, сразу после получения оценки.

Пример модификации алгоритма минимакса с альфа-бета отсечением (для большей наглядности, внесенные модификации закомментированы, но помните, что это важный код, а не комментарии):

int Game::runMinMax(MonsterType monster, int recursiveLevel/*, int alpha, int beta*/) { int test = NOT_INITIALIZED; if (recursiveLevel >= this->AILevel * 2) return getHeuristicEvaluation(); int bestMove = NOT_INITIALIZED; bool isWolf = (monster == MT_WOLF); int MinMax = isWolf ? MIN_VALUE: MAX_VALUE; for (int i = (isWolf ? 0: 8); i < (isWolf ? 8: 12); i++) { int curMonster = isWolf ? i / 2 + 1: 0; QPoint curMonsterPos = curMonster == 0 ? this->rabbit: this->wolfs; QPoint curMove = this->possibleMoves; if (canMove(curMonsterPos + curMove)) { temporaryMonsterMovement(curMonster, curMove); test = runMinMax(isWolf ? MT_RABBIT: MT_WOLF, recursiveLevel + 1, alpha, beta); temporaryMonsterMovement(curMonster, -curMove); if ((test > MinMax && monster == MT_WOLF) || (test <= MinMax && monster == MT_RABBIT)) { MinMax = test; bestMove = i; } /* if (isWolf) alpha = qMax(alpha, test); else beta = qMin(beta, test); if (beta < alpha) break; */ } } if (bestMove == NOT_INITIALIZED) return getHeuristicEvaluation(); if (recursiveLevel == 0 && bestMove != NOT_INITIALIZED) { if (monster == MT_WOLF) this->wolfs += this->possibleMoves; else this->rabbit += this->possibleMoves; } return MinMax; }
Как я уже говорил ранее, альфа-бета отсечение очень эффективно, и доказательством тому является приведенные ниже показатели. Для каждого случая, на трех разных уровнях глубины расчетов, я замерял количество входов в функцию эвристической оценки (меньше – лучше), и вот что получилось:


Как вывод, могу сказать что использование этого алгоритма отсечения не только ускорит работу интеллекта, но и позволит повысить его уровень.

Нюансы

Алгоритм делает оптимальные ходы, только если его противник мыслит оптимально. Качество хода в основном зависит от глубины рекурсии, и от качества эвристики. Но следует отметить, что этот алгоритм оценивает качество хода достаточно глубоко, и никоим образом не завязывается (если явно не прописать где-то в эвристике) на количество ходов. Другими словами, если применить этот алгоритм к шахматам, без дополнительных модификаций, он будет ставить маты позже, чем мог бы. А в данном примере, если заяц поймет, что у него нет пути на победу, при оптимальной стратегии волков, он может покончить жизнь самоубийством, несмотря на то, что он мог бы оттягивать проигрыш.

Еще раз, никогда не делайте условием для альфа-бета отсечения alpha >= beta, если вы не на 100% уверены, что для вашей реализации это допустимо. Иначе ваша альфа-бета ухудшит интеллектуальность алгоритма в целом, с высокой долей вероятности.

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

• Повторно использовать вычисления.
• Анализировать разные ситуации с разной глубиной
• Увеличивать количество отсечений, за счет общих принципов и эвристик для конкретной игры.
• Внедрять шаблоны ходов. Например, в шахматах первые несколько ходов – дебюты, а не работа минимакса.
• Внедрять сторонние мерки качества ходов. Например, проверять, можно ли победить одним ходом, и если можно - победить, а не минимакс запускать.
• Многое другое.

Колоссальное количество модификаций и позволяют компьютеру играть в шахматы, и даже обыгрывать человека. Без таких модификаций, минимакс к шахматам практически не применим, даже на современных супер компьютерах. Без оптимизаций, в шахматах для трех ходов нужно было бы проверить порядка 30^6 ходов (729 миллиардов), а нам нужно, чтобы глубина расчета была побольше…

Найти минимакс и максимакс (определить нижнюю и верхнюю границы игры).

Решаем через калькулятор . 1. Проверяем, имеет ли платежная матрица седловую точку . Если да, то выписываем решение игры в чистых стратегиях.
Считаем, что игрок I выбирает свою стратегию так, чтобы получить максимальный свой выигрыш, а игрок II выбирает свою стратегию так, чтобы минимизировать выигрыш игрока I.

Игроки	B 1	B 2	B 3	B 4	a = min(Ai)
A 1	5	0	6	8	0
A 2	1	0	5	4	0
A 3	7	9	6	5	5
A 4	6	5	2	1	1
b = max(Bi)	7	9	6	8	0

Находим гарантированный выигрыш, определяемый нижней ценой игры a = max(a i) = 5, которая указывает на максимальную чистую стратегию A 3 .
Верхняя цена игры b = min(b j) = 6.
Что свидетельствует об отсутствии седловой точки, так как a ≠ b, тогда цена игры находится в пределах 5 ≤ y ≤ 6. Находим решение игры в смешанных стратегиях. Объясняется это тем, что игроки не могут объявить противнику свои чистые стратегии: им следует скрывать свои действия. Игру можно решить, если позволить игрокам выбирать свои стратегии случайным образом (смешивать чистые стратегии).

2. Проверяем платежную матрицу на доминирующие строки и доминирующие столбцы .
Иногда на основании простого рассмотрения матрицы игры можно сказать, что некоторые чистые стратегии могут войти в оптимальную смешанную стратегию лишь с нулевой вероятностью.
Говорят, что i-я стратегия 1-го игрока доминирует его k-ю стратегию, если a ij ≥ a kj для всех jЭ N и хотя бы для одного j a ij > a kj . В этом случае говорят также, что i-я стратегия (или строка) – доминирующая, k-я – доминируемая.
Говорят, что j-я стратегия 2-го игрока доминирует его l-ю стратегию, если для всех j Э M a ij ≤ a il и хотя бы для одного i a ij < a il . В этом случае j-ю стратегию (столбец) называют доминирующей, l-ю – доминируемой.
Стратегия A1 доминирует над стратегией A2 (все элемент строки 1 больше или равны значениям 2-ой строки), следовательно исключаем 2-ую строку матрицы.
Стратегия A3 доминирует над стратегией A4 (все элемент строки 3 больше или равны значениям 4-ой строки), следовательно исключаем 4-ую строку матрицы.

5	0	6	8
7	9	6	5

В платежной матрице отсутствуют доминирующие столбцы и доминирующие строки.
Так как игроки выбирают свои чистые стратегии случайным образом, то выигрыш игрока I будет случайной величиной. В этом случае игрок I должен выбрать свои смешанные стратегии так, чтобы получить максимальный средний выигрыш .
Аналогично, игрок II должен выбрать свои смешанные стратегии так, чтобы минимизировать математическое ожидание игрока I.

3. Находим решение игры в смешанных стратегиях .
Запишем систему уравнений.
Для игрока I
5p 1 +7p 2 = y
+9p 2 = y
6p 1 +6p 2 = y
8p 1 +5p 2 = y
p 1 +p 2 = 1
Для игрока II
5q 1 +6q 3 +8q 4 = y
7q 1 +9q 2 +6q 3 +5q 4 = y
q 1 +q 2 +q 3 +q 4 = 1

метод минимакса , нашедший широкое применение в теории игр. Предположим, что противник использует оценочную функцию (ОФ), совпадающую с нашей ОФ. Выбор хода с нашей стороны определяется максимальным значением ОФ для текущей позиции. Противник стремится сделать ход, который минимизирует ОФ. Поэтому этот метод и получил название минимакса . На рис. 3.5 приведен пример анализа дерева ходов с помощью метода минимакса (выбранный путь решения отмечен жирной линией).

Рис. 3.5.

Развивая метод минимакса , назначим вероятности для выполняемых действий в задаче о миссионерах и людоедах:

P(R) = 0; 8; P(R) = 0; 5; P(R) = 0; 9; P(R) = 0; 3; P(R) = 0; 3:

Интуитивно понятно, что посылать одного людоеда или одного миссионера менее эффективно, чем двух человек, особенно на начальных этапах. На каждом уровне мы будем выбирать состояние по критерию P i . Даже такой простой подход позволит нам избежать части тупиковых состояний в процессе поиска и сократить время по сравнению с полным перебором. Кстати, этот подход достаточно распространен в экспертных продукционных системах.

Альфа-бета-процедура

Теоретически, это эквивалентная минимаксу процедура, с помощью которой всегда получается такой же результат, но заметно быстрее, так как целые части дерева исключаются без проведения анализа. В основе этой процедуры лежит идея Дж. Маккарти об использовании двух переменных, обозначенных и (1961 год).

Основная идея метода состоит в сравнении наилучших оценок, полученных для полностью изученных ветвей, с наилучшими предполагаемыми оценками для оставшихся. Можно показать, что при определенных условиях некоторые вычисления являются лишними. Рассмотрим идею отсечения на примере рис. 3.6 . Предположим, позиция А полностью проанализирована и найдено значение ее оценки Допустим, что один ход из позиции Y приводит к позиции Z , оценка которой по методу минимакса равна z . Предположим, что . После анализа узла Z , когда справедливо соотношение , ветви дерева, выходящие из узла Y , могут быть отброшены (альфа-отсечение).

Рис. 3.6.

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

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

Правила прекращения поиска:

На рис. 3.7 показаны отсечения для конкретного примера. Таким образом, -алгоритм дает тот же результат, что и метод минимакса , но выполняется быстрее.

Рис. 3.7.

Использование, применяемые человеком: выдвигаются подцели, приближающие к решению; применяется эвристический метод (один, другой и т. д.), пока не будет получено решение. Попытки прекращаются, если получить решение не удается.

Программа STRIPS (STanford Research Institut Problem Solver) вырабатывает соответствующий порядок действий робота в зависимости от поставленной цели. Программа способна обучаться на опыте решения предыдущих задач. Большая часть игровых программ также обучается в процессе работы. Например, знаменитая шашечная программа Самюэля, выигравшая в 1974 году у чемпиона мира, "заучивала наизусть" выигранные партии и обобщала их для извлечения пользы из прошлого опыта. Программа HACHER Зуссмана, управляющая поведением робота, обучалась также и на ошибках.

Вполне возможно, что после сотен партий в «крестики-нолики» вы задумывались: каков же оптимальный алгоритм? Но если вы здесь, то вы наверняка ещё и пробовали написать реализацию этой игры. Мы пойдём дальше и напишем бота, который будет невозможно обыграть в «крестики-нолики». Предугадав ваш вопрос «почему?», ответим: благодаря алгоритму .

Как и профессиональный шахматист, этот алгоритм просчитывает действия соперника на несколько ходов вперёд - до тех пор, пока не достигнет конца партии, будь то победа, поражение или ничья. Попав в это конечное состояние, ИИ начислит себе положительное количество очков (в нашем случае +10) за победу, отрицательное (-10) - за поражение, и нейтральное (0) - за ничью.

В то же время алгоритм проводит аналогичные расчёты для ходов игрока. Он будет выбирать ход с наиболее высоким баллом, если ходит ИИ, и ход с наименьшим, если ходит игрок. Используя такую стратегию, минимакс избегает поражения.

Попробуйте сыграть вот в такую игру.

Алгоритм «минимакс» проще всего описать в виде рекурсивной функции, которая:

1. возвращает значение, если найдено конечное состояние (+10, 0, -10),
2. проходит по всем пустым клеткам на поле,
3. вызывает минимакс-функцию для каждой из них (рекурсия),
4. оценивает полученные значения
5. и возвращает наилучшее из них.

Если вы не знакомы с рекурсией, то вам стоит посмотреть эту лекцию из гарвардского курса CS50:

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

Реализация минимакса

Мы рассмотрим ситуацию, когда игра подходит к концу (смотрите картинку ниже). Поскольку минимакс проходит по всем возможным состояниям игры (а их сотни тысяч), имеет смысл рассматривать эндшпиль - так нам придётся отслеживать меньшее количество рекурсивных вызовов функции (всего 9).

Пусть ИИ играет крестиками, человек - ноликами.

Чтобы упростить работу с полем, объявим его как массив из 9 элементов со значениями, равными содержимому клеток. Заполним его крестиками и ноликами, как на картинке выше, и назовём origBoard .

Var origBoard = ["O",1,"X","X",4,"X",6,"O","O"];

Затем объявим переменные aiPlayer и huPlayer и присвоим им значения "X" и "O" соответственно.

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

/* начальное состояние доски O | | X --------- X | | X --------- | O | O */ var origBoard = [“O”,1 ,”X”,”X”,4 ,”X”, 6 ,”O”,”O”]; // человек var huPlayer = “O”; // ИИ var aiPlayer = “X”; // возвращает список индексов пустых клеток доски function emptyIndices(board){ return board.filter(s => s != "O" && s != "X"); } // победные комбинации с учётом индексов function winning(board, player){ if((board == player && board == player && board == player) || (board == player && board == player && board == player) || (board == player && board == player && board == player) || (board == player && board == player && board == player) || (board == player && board == player && board == player) || (board == player && board == player && board == player) || (board == player && board == player && board == player) || (board == player && board == player && board == player)) { return true; } else { return false; } }

Итак, давайте определим минимакс-функцию с двумя аргументами: newBoard (новое поле) и player (игрок). Затем найдём индексы свободных клеток на поле и передадим их в переменную availSpots .

// основная минимакс-функция function minimax(newBoard, player){ //доступные клетки var availSpots = emptyIndices(newBoard);

Кроме того, нам нужно отслеживать конечные состояния и возвращать соответствующие значения. Если побеждает «нолик», нужно вернуть -10 , если «крестик» - +10 . Если размер массива availSpots равен нулю, значит, свободных клеток нет, игра закончится ничьёй, и нужно вернуть ноль.

// проверка на терминальное состояние (победа / поражение / ничья) //and returning a value accordingly if (winning(newBoard, huPlayer)){ return {score:-10}; } else if (winning(newBoard, aiPlayer)){ return {score:10}; } else if (availSpots.length === 0){ return {score:0}; }

После этого нужно собрать очки с каждой из пустых клеток. Для этого создадим массив ходов moves и пройдём в цикле по всем пустым клеткам, помещая индексы и очки каждого хода в объект move .

Затем зададим индекс пустой клетки, который хранился в виде числа в origBoard , равным свойству-индексу объекта move . Потом сходим за текущего игрока на пустую клетку нового поля newBoard и вызовем функцию minimax от другого игрока и получившегося поля newBoard . После этого нужно поместить свойство score объекта, возвращённого функцией minimax , в свойство score объекта move .

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

И наконец, функция сбрасывает изменения newBoard и помещает объект move в массив moves .

// массив для хранения всех объектов var moves = ; // цикл по доступным клеткам for (var i = 0; i < availSpots.length; i++){ //create an object for each and store the index of that spot var move = {}; move.index = newBoard]; // совершить ход за текущего игрока newBoard] = player; //получить очки, заработанные после вызова минимакса от противника текущего игрока if (player == aiPlayer){ var result = minimax(newBoard, huPlayer); move.score = result.score; } else{ var result = minimax(newBoard, aiPlayer); move.score = result.score; } // очистить клетку newBoard] = move.index; // положить объект в массив moves.push(move); }

Затем минимаксу нужно выбрать наилучший ход move из массива moves . Ему нужен move с наибольшим счётом, если ходит ИИ, и с наименьшим, если это ход человека. Таким образом, если значение player равно aiPlayer , алгоритм инициализирует переменную bestScore очень маленьким числом и идёт циклом по массиву moves: если ход move приносит больше очков score , чем bestScore , алгоритм запоминает этот move . В случае ходов с одинаковыми очками алгоритм запоминает первый из них.

В случае, когда player равен huPlayer , всё аналогично - только теперь bestScore инициализируется большим числом, а минимакс ищет ход move с наименьшим количеством очков.

В итоге минимакс возвращает объект, хранящийся в bestMove .

// если это ход ИИ, пройти циклом по ходам и выбрать ход с наибольшим количеством очков var bestMove; if(player === aiPlayer){ var bestScore = -10000; for(var i = 0; i < moves.length; i++){ if(moves[i].score > bestScore){ bestScore = moves[i].score; bestMove = i; } } }else{ // иначе пройти циклом по ходам и выбрать ход с наименьшим количеством очков var bestScore = 10000; for(var i = 0; i < moves.length; i++){ if(moves[i].score < bestScore){ bestScore = moves[i].score; bestMove = i; } } } // вернуть выбранный ход (объект) из массива ходов return moves; }

В следующем разделе мы смоделируем работу нашей программы, чтобы понять, как она работает.

Минимакс в действии

Пользуясь схемой ниже, разберем пошаговую модель алгоритма.

Примечание : На схеме большие числа обозначают порядковый номер вызова функции, а уровни - то, на сколько ходов вперёд прошёл алгоритм.

1. Алгоритму подаются origBoard и aiPlayer . Он составляет список из трёх найденных пустых клеток, проверяет конечность состояния, и проходит циклом по всем пустым клеткам. Затем алгоритм меняет newBoard , помещая aiPlayer в первую пустую клетку. После этого он вызывает сам себя от newBoard и huPlayer и ждёт, пока второй вызов вернёт значение.
2. Пока первый вызов функции всё ещё работает, запускается второй, создавая список из двух пустых клеток, проверяя конечность состояния и проходя циклом по всем пустым клеткам. Затем второй вызов изменяет newBoard , помещая huPlayer в первую пустую клетку. После этого он вызывает сам себя от newBoard и aiPlayer и ждёт, пока третий вызов вернёт значение.
3. 
   

   Поскольку второй вызов обнаружил две пустые клетки, минимакс изменяет newBoard , помещая huPlayer во вторую свободную клетку. Затем он вызывает сам себя от newBoard и aiPlayer .

4. Алгоритм составляет список пустых клеток и фиксирует победу игрока после проверки конечности состояния. Поэтому он возвращает объект с полем счёта, равным (-10).
   

   Во втором вызове функции алгоритм получает значения, возвращённые с нижнего уровня третьим и четвёртым вызовами функции. Поскольку ход huPlayer принёс эти два результата, алгоритм выбирает наименьший из них. Так как они одинаковы, алгоритм выбирает первый и передаёт его первому вызову функции.

   На этот момент первый вызов функции получил оценку хода aiPlayer в первую пустую клетку. Затем он изменяет newBoard , помещая aiPlayer во вторую пустую клетку. После этого он вызывает сам себя от newBoard и huPlayer .

5. В пятом вызове функции алгоритм составляет список пустых клеток и фиксирует победу ИИ после проверки конечности состояния. Поэтому он возвращает объект с полем счёта, равным +10.
   

   После этого первый вызов изменяет newBoard , помещая aiPlayer в третью пустую клетку. Затем он вызывает сам себя от newBoard и huPlayer .

6. Шестой вызов составляет список из двух пустых клеток, проверяет конечность состояния и идёт циклом по всем пустым клеткам. Затем он изменяет newBoard , помещая huPlayer в первую пустую клетку. Потом он вызывает сам себя от newBoard и aiPlayer и ждёт, пока седьмой вызов вернёт значение.
7. Новый вызов составляет список из одной пустой клетки, проверяет конечность состояния и изменяет newBoard , помещая aiPlayer в пустую клетку. После этого он вызывает сам себя от newBoard и huPlayer и ждёт, пока этот вызов вернёт значение.
8. Восьмой вызов составляет пустой список пустых клеток и фиксирует победу aiPlayer после проверки конечности состояния. Поэтому он возвращает объект с полем счёта, равным (+10), на уровень выше, седьмому вызову.
   

   Седьмой вызов получил лишь одно, положительное значение от нижних уровней. Поскольку это значение было получено в ход aiPlayer , алгоритм возвращает наибольшее из полученных значений. Поэтому он возвращает положительное значение (+10) на уровень выше, шестому вызову.

   Поскольку шестой вызов обнаружил две пустых клетки, минимакс изменяет newBoard , помещая huPlayer во вторую пустую клетку. Затем он вызывает сам себя от newBoard и aiPlayer .

9. После этого алгоритм составляет список пустых клеток и фиксирует победу aiPlayer после проверки конечности состояния. Поэтому он возвращает объект с полем счёта, равным (+10), на уровень выше.
   

   На этом этапе шестой вызов должен выбрать между счётом (+10), который вернул седьмой вызов, и счётом (-10), который вернул девятый вызов. Поскольку ход huPlayer принёс эти два результата, алгоритм выбирает наименьший из них и возвращает его на уровень выше в виде объекта с полями счёта и индекса.

   Наконец, все три ветви первого вызова оцениваются (-10, +10, -10). Поскольку ход aiPlayer принёс эти три результата, алгоритм выбирает объект, содержащий наибольшее количество очков (+10) и его индекс (4).

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

В 1945 году Оскар Моргенштерн и Джон фон Нейман предложили метод минимакса , нашедший широкое применение в теории игр. Предположим, что противник использует оценочную функцию (ОФ), совпадающую с нашей ОФ. Выбор хода с нашей стороны определяется максимальным значением ОФ для текущей позиции. Противник стремится сделать ход, который минимизирует ОФ. Поэтому этот метод и получил название минимакса. Нарис. 3.5 приведен пример анализа дерева ходов с помощьюметода минимакса (выбранный путь решения отмечен жирной линией).

Рис. 3.5. Дерево ходов

Развивая метод минимакса , назначим вероятности для выполняемых действий в задаче о миссионерах и людоедах:

P(R) = 0; 8; P(R) = 0; 5;

P(R) = 0; 9;

P(R) = 0; 3; P(R) = 0; 3:

Интуитивно понятно, что посылать одного людоеда или одного миссионера менее эффективно, чем двух человек, особенно на начальных этапах. На каждом уровне мы будем выбирать состояние по критерию P i . Даже такой простой подход позволит нам избежать части тупиковых состояний в процессе поиска и сократить время по сравнению с полным перебором. Кстати, этот подход достаточно распространен в экспертных продукционных системах.

Альфа-бета-процедура

Теоретически, это эквивалентная минимаксу процедура, с помощью которой всегда получается такой же результат, но заметно быстрее, так как целые части дерева исключаются без проведения анализа. В основе этой процедуры лежит идея Дж. Маккарти об использовании двух переменных, обозначенных иβ(1961 год).

Основная идея метода состоит в сравнении наилучших оценок, полученных для полностью изученных ветвей, с наилучшими предполагаемыми оценками для оставшихся. Можно показать, что при определенных условиях некоторые вычисления являются лишними. Рассмотрим идею отсечения на примере рис. 3.6 . Предположим, позицияАполностью проанализирована и найдено значение ее оценки . Допустим, что один ход из позицииYприводит к позицииZ, оценка которой пометоду минимакса равнаz. Предположим, чтоz . После анализа узлаZ, когда справедливо соотношениеy z s, ветви дерева, выходящие из узлаY, могут быть отброшены (альфа-отсечение).

Рис. 3.6. - отсечение

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

Отсечение типа βможно выполнить всякий раз, когда оценка позиции, возникающая после хода противника, превышает значениеβ. Алгоритм поиска строится так, что оценки своих ходов и ходов противника сравниваются при анализе дерева с величинами иβсоответственно. В начале вычислений этим величинам присваиваются значения+∞и-∞, а затем, по мере продвижения к корню дерева, находится оценка начальной позиции и наилучший ход для одного из противников.

Правила прекращения поиска:

На рис. 3.7 показаны -βотсечения для конкретного примера. Таким образом, -β-алгоритм дает тот же результат, что иметод минимакса , но выполняется быстрее.

Рис. 3.7. a-b отсечение для конкретного примера

Использование алгоритмов эвристического поиска для поиска на графе И, ИЛИ выигрышнойстратегии в более сложных задачах и играх (шашки, шахматы) не реален. По некоторым оценкам игровое дерево игры в шашки содержит 10 40 вершин, в шахматах 10 120 вершин. Если при игре в шашки для одной вершины требуется 1/3 наносекунды, то всего игрового времени потребуется 10 21 веков. В таких случаях вводятся искусственные условия остановки, основанные на таких факторах, как наибольшая допустимая глубина вершин в дереве поиска или ограничения на время и объем памяти.

Многие из рассмотренных выше идей были использованы А. Ньюэллом, Дж. Шоу и Г. Саймоном в их программе GPS. Процесс работы GPS в общем воспроизводит методы решения задач , применяемые человеком: выдвигаются подцели, приближающие к решению; применяетсяэвристический метод (один, другой и т. д.), пока не будет получено решение. Попытки прекращаются, если получить решение не удается.

Программа STRIPS (STanford Research Institut Problem Solver) вырабатывает соответствующий порядок действий робота в зависимости от поставленной цели. Программа способна обучаться на опыте решения предыдущих задач. Большая часть игровых программ также обучается в процессе работы. Например, знаменитая шашечная программа Самюэля, выигравшая в 1974 году у чемпиона мира, "заучивала наизусть" выигранные партии и обобщала их для извлечения пользы из прошлого опыта. Программа HACHER Зуссмана, управляющая поведением робота, обучалась также и на ошибках.