Создаем библиотеку теории игр на питоне: как вообще это будет работать?

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

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

Скорее всего, здесь подойдет метод "выгрызания дыр в сыре, пока весь сыр не будет съеден" - при этом мы пока не представляем истинных размеров сыра, но можем выгрызать те области, которые на сегодня более-менее понятны...

Сегодня сделаем наброски примеров кода работы с библиотекой (как если бы библиотека была полностью готовой) - это поможет в дальнейшем при создании классов, их атрибутов и методов и в целом, задаст ориентиры для дальнейшей работы. Напишем очередной класс Очередь Игроков. А ещё поддадимся модной тенденции и спросим совета у ChatGPT-3...

В предыдущих статьях мы:

• Набросали массу требований - как должна выглядеть идеальная библиотека, решающая задачи методом теории игр

• Разработали структуру классов, которые будут в нашей библиотеке

В этой статье мы:

1. Набросаем примеры кода - как вообще могла бы работать такая библиотека? Создадим примеры кода для исследования нескольких классических задач.

2. Спросим у ChatGPT-3, какие методы и атрибуты она порекомендовала бы для наших классов.

3. Реализуем класс Очередь Игроков (Queue) - один из центральных классов в любой Игре.

1. Примеры кода работы библиотеки

Итак, набросаем примеры того, как могла бы работать наша библиотека...

Загрузка и подготовка

Здесь все должно работать, как при обычной загрузке python-библиотек:

pip install my_python_game_theory_library

import my_python_game_theory_library as gtl

Одновременная игра с простой матрицей

Создадим игру, в которой 2 Игрока ходят одновременно, выигрывая случайное количество очков в зависимости от выбранного варианта.

Для этого мы создадим:

• двух Игроков,

• Игральные кости, которые будут привязаны к отдельным вариантам/опциям выбора Игроков (Игрок выбирает опцию - какую кость бросить, либо выбрать фиксированный выигрыш),

• сами варианты/опции и матрицу Игры с ними

import my_python_game_theory_library as gtl

# Создадим 2 Игроков
p1 = gtl.Player()
p2 = gtl.Player()

print(p1.name)  # 'Player_1'
print(p2.name)  # 'Player_2'

# Создадим классическую Игральную кость
d1 = gtl.Dice(faces = (1,6))
# Создадим нестандартную Игральную кость - 
# равноценные грани с разными очками, 1 и 6 выпадут с вероятностью 1/3, 
# а 2 и 5 - с вероятностью 1/6
d2 = gtl.Dice(faces = [1,1,2,5,6,6])

print(d1.name)  # 'Dice_1'
print(d2.name)  # 'Dice_2'

# Создадим опции Стандарт, Риск, Фиксированная с разными исходами
o1 = gtl.Option(name='Standart', benefits=d1)
o2 = gtl.Option(name='Risk', benefits=d2)
o3 = gtl.Option(name='Fix', benefits=3)

# Создадим матрицу Игры, одинаковую для всех Игроков
# Можно задавать опции как по именам, так и по ссылкам на экземпляр класса (o3)
m = gtl.Matrix(name='Matrix_3_types', options=['Standart', 'Risk', o3])

# Игра, где у каждого Игрока есть выбор между 3 опциями
# Очередь Игроков можно было бы задать и так: players = [p1, p2]
# is_parallel=True означает, что все Игроки делаю ходы/ставки одновременно, 
# поэтому очередь queues - это просто список участвующих Игроков, без очередности
g1 = gtl.Game(name='Simple_game_3_options', 
              queues=['Player_1', 'Player_2'],
              matrices='Matrix_3_types',
              is_parallel=True
             )

# Сыграем 3 раунда, в каждом из которых кажыдый Игрок выберет одну из опций
g1.play(rounds=3) # Выводит таблицу результатов каждого Игрока

'Simple_game_3_options', rounds=3

Player_1: 12
Player_2: 15

Одновременная игра с матрицей, зависящей от хода другого Игрока

Это игры типа "дилемма заключенных" (их разбор с существующими библиотеками nashpy и axelrod можно посмотреть в предыдущей статье).

Особенность игры в том, что выигрыш каждого Игрока зависит от того, какой ход сделает другой Игрок (Игроки).

import my_python_game_theory_library as gtl

# Создадим 2 Игроков
gtl.Player(name='Федор')
gtl.Player(name='Теодор')

# Создадим матрицу Игры, содержащую варианты/опции для выбора каждым Игроком
gtl.Matrix(name='Matrix_dilemma', options=[[(-3,-3), (0,-6)], [(-6,0), (-1,-1)]])

game_dilemma = gtl.Game(name='Dilemma', 
                        queues=['Player_1', 'Player_2'],
                        matrices='Matrix_dilemma',
                        is_parallel=True
                       )

# Сыграем 3 раунда, в каждом из которых кажыдый Игрок выберет одну из опций
game_dilemma.play(rounds=3) # Выводит таблицу результатов каждого Игрока

Поочередная игра с деревом вариантов

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

При этом, выбор очередным Игроком варианта/опции приводит к сворачиванию на определенную развилку, со своими вариантами.

import my_python_game_theory_library as gtl

# Создадим 2 Игроков и очередность в порядке создания
gtl.Player(name='Федор')
gtl.Player(name='Теодор')
q1 = gtl.Queue(priority = gtl.Player.all)

# Создадим 4 Игральные кости

# Создадим классическую Игральную кость
d1 = gtl.Dice(faces = (1,6))

# Создадим нестандартную Игральную кость - 
# равноценные грани с разными очками, 1 и 6 выпадут с вероятностью 1/3, 
# а 2 и 5 - с вероятностью 1/6
d2 = gtl.Dice(faces = [1,1,2,5,6,6])

# Создадим нестандартную Игральную кость
d3 = gtl.Dice(faces = [1,3,3,3,3,6])

# Создадим нестандартную Игральную кость c разными вероятностями броска
# разных костей
d4 = gtl.Dice(faces = {d2:0.4, d3:0.6})

# Создадим экземпляр класса опции, как дерево вариантов 
# с максимум 2 уровнями:
o1 = gtl.Option(is_tree=True, max_levels=2)
# На первом уровне Игрок может выбрать бросок кости 1 или 2
o1.set_level(num_level=0, variants={'v1':d1, 'v2':d2})
# На втором уровне следующий Игрок может выбрать бросок кости 2 или 3,
# если первый выбрал v1, и 3 или 4, если первый выбрал v2
o1.set_level(num_level=2, variants=[{'v1':d2, 'v2':d3}, 
                                    {'v1':d3, 'v2':d4}})

game_tree = gtl.Game(name='Tree', 
                     queues=q1,
                     options=o1,
                     is_parallel=False  # Игра поочередная, согласно списку
                    )

# Сыграем 10 раундов
# Подсчет результатов по итогам раундов counting='binary',
# что означает, что за 1 место дается 1, за последующие - 0
# Возможны также 'sum' - сумма набранных баллов и 'avg' - их среднее
game_tree.play(rounds=10, counting='binary') # Выводит таблицу результатов каждого Игрока

Игра, в которой нужно выбирать число в интервале

Игра типа "Ультиматум", в которой Игрок 1 получает сумму X и должен предложить Игроку 2 ее часть (от 0 до X). Если Игрок 2 соглашается, то оба получают деньги, если нет - никто не получает. Далее Игрок 2 получает для раздела сумму Y. Эти суммы могут быть заданными, например, 10 монет, либо выбираться броском кубика - используем кубик с гранями от 5 до 10 включительно.

import my_python_game_theory_library as gtl

# Создадим 2 Игроков и очередность в порядке создания
gtl.Player(name='Федор')
gtl.Player(name='Теодор')

# Разобъем игроков на партии по 2 человека 
q1 = gtl.Queue(priority = gtl.Player.all, 
               parties=2, 
               parties_type='permutations')

game_ultim = gtl.Game(name='Ultim', 
                     queues=q1,
                     options=(0,10),  # Опции - выбор суммы от 0 до 10
                     options_type='partition',  # Тип - раздел суммы
                     condition='all',  # Условия получения - все согласны 
                     is_parallel=False  # Игра поочередная, согласно списку
                    )

# Сыграем 10 раундов
# Подсчет результатов по итогам раундов counting='sum',
# - сумма набранных баллов
game_ultim.play(rounds=10, counting='sum') # Выводит таблицу результатов каждого Игрока

Английский аукцион с очередностью

Игра, в которой на аукцион выставляется товар (класс Ресурс), и есть несколько Игроков-покупателей (случайное число от 3 до 10), каждый из которых оценивает Ресурс индивидуально, например, от 50 до 100 монет. Пусть Игроки называют свои ставки по очереди, либо говорят "пас". Побеждает тот, после которого все говорят "пас". Торговля начинается с определенной суммы, которая выбирается случайно в интервале (25, 75). Ставку можно увеличивать на фиксированную сумму - пусть случайно выбирается в интервале (1, 10).

import my_python_game_theory_library as gtl

# Создадим Игральную кость, выбирающую от 3 до 10 Игроков
d1 = gtl.Dice(faces=(3,10))

# Создадим Игральную кость, выбирающую ценность ресурса для Игрока -
# от 50 до 100 монет
d2 = gtl.Dice(faces=(50,100))

# Создадим Игральную кость, выбирающую начальную ставку -
# от 25 до 75 монет
d3 = gtl.Dice(faces=(25,75))

# Создадим Ресурс
r1 = gtl.Resource(name='Ценная картина', count=1)

# Создадим случайное кол-во Игроков со случайной оценкой Ресурса 
gtl.create(create_class='Player', num=d1, values={'Ценная картина': d2})

# И очередность в порядке создания
q1 = gtl.Queue(priority = gtl.Player.all)

game_auct = gtl.Game(name='Auction', 
                     queues=q1,
                     options=['bid', 'pass'],  # Опции - ставка или пас
                     options_type='eng_auction',  # Тип - английский аукцион
                     condition='last',  # Условия получения - последняя ставка
                     resourses=r1,  # Выставленный на аукцион ресурс, либо список
                     starting_prices=d3,
                     is_parallel=False  # Игра поочередная, согласно списку
                    )

# Сыграем аукцион
game_auct.play(rounds=1) # Выводит таблицу ставок каждого Игрока и победителя

Классический базар - много товаров, продавцов и много покупателей

Случайно выбирается несколько Ресурсов (от 3 до 5). Случайно выбирается количество Игроков (от 3 до 10), у каждого от 0 до 10 единиц каждого Ресурса. Каждый Игрок оценивает каждый Ресурс в определенную сумму и готов поменять его на другой, если ему предложат лучший.

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

import my_python_game_theory_library as gtl

# Создадим Игральную кость, выбирающую от 3 до 10 Игроков
d1 = gtl.Dice(faces=(3,10))

# Создадим Игральную кость, выбирающую количество Ресурсов для обмена -
# от 3 до 5
d2 = gtl.Dice(faces=(3,5))

# Создадим Игральную кость, выбирающую ценность ресурса для Игрока -
# от 1 до 10 монет
d3 = gtl.Dice(faces=(1,10))

# Создадим Игральную кость, выбирающую количество Ресурсов у Игрока -
# от 0 до 10
d4 = gtl.Dice(faces=(0,10))

# Создадим Ресурсы
gtl.create(create_class='Resource', num=d2)

# Создадим случайное кол-во Игроков со случайным количеством ресурсов
# и случайной оценкой Ресурса 
gtl.create(create_class='Player', 
           num=d1, 
           resourses=(gtl.Resource.all, d4),
           values=(gtl.Resource.all, d3))

# И список Игроков для обмена
q1 = gtl.Queue(priority = gtl.Player.all)

game_change = gtl.Game(name='Change', 
                     queues=q1,
                     options=['change', 'pass'],  # Опции - меняюсь или пас
                     options_type='change',  # Тип - обмен ресурсами
                     condition='over',  # Условия обмена - выше ценность
                     resourses=gtl.Resource.all,  # Список ресурсов
                     is_parallel=False  # Игра поочередная, согласно списку
                    )

# Сыграем обмен
# Выводит таблицы всех обменов, ресурсов и эффектов каждого Игрока
game_change.play(outs=['changes', 'resourses', 'effects']) 

2. Спросим совета у ChatGPT-3

Сразу выскажу резюме: если раньше гугление или поиск в Яндексе сравнивали с затратами времени и сил на поход в библиотеку и поиск там информации доступными средствами (каталоги в шкафчиках), то в данном случае ответы ChatGPT-3 можно сравнить с виртуальным консилиумом или даже мозговым штурмом целой банды специалистов в теории игр, ООП и написании библиотек на питоне... Убедитесь сами (по ссылке полный список вопросов-ответов по построению библиотеки):

Вопросы задавались на английском, ответы переведены на русский.

Я хочу разработать код библиотеки на питоне для решения разнообразных задач методами теории игр. Какие рекомендации ты можешь мне дать по разработке такой библиотеки?

Ок, давай начнем с пункта 1 твоей предыдущей рекомендации. Напиши топ-10 параметров и характеристик, которые может иметь игра в теории игр. Например, количество игроков, последовательные или одновременные ходы и тому подобное.

Уточни про типы игры: назови топ-10 типов игры в теории игр, кроме названных (кооперативные и некооперативные игры, игры с нулевой суммой и ненулевыми суммами).

Перейдем к конкретике:

Какие топ-10 классов в библиотеке на питоне для решения задач методами теории игр ты предложить создать? Напиши названия классов и их краткое описание

Попробуем раскрутить ИИ думать в том же направлении, что и я - каждая сущность - отдельный класс:

Хорошо, но я хотел бы каждую сущность в теории игр выделить в отдельный класс. Например, класс Player. Какие топ-10 классов ты порекомендуешь?

Предложим свои классы и попросим объяснить, как она понимает их свойства:

Я хочу разработать код библиотеки на питоне для решения разнообразных задач методами теории игр.

У меня будут классы: Game, Player, Queue, Coalition, Strategy, Option, Benefit, Situation, Matrix, Resource, Dice.

Как, по-твоему, должны быть связаны эти классы?

Далее серия вопросов, которая выжимает из ИИ максимум знаний об атрибутах и методах класса Игрок - Player (очевидно, он изучил большое количество кода, где есть такой класс - а он есть во многих играх!)

Отлично, какие топ-10 атрибутов ты мог бы предложить для класса Player?

Полный список вопросов и ответов на момент написания статьи доступен по ссылке

3. Реализуем класс Queue - Очередь Игроков

Экземпляры класса Queue - Очередь Игроков содержат список Игроков.

Этот список, priority, передается в экземпляр Игры.

• Если ходы в Игре происходят одновременно, то список Игроков - это множество Игроков, без очередности.

• Если ходы в Игре происходят поочерёдно, то список Игроков - это очередь Игроков.

• Игра может происходить по партиям, когда Игроки разбиваются на пары, тройки, четверки и т.п. и играют "каждый с каждым". За это отвечают атрибуты parties - количество Игроков в такой партии, parties_type - комбинации, перестановки, случайное формирование партии Игроков, max_parties- максимальное количество партий, если задано (например, при случайном формировании партии).

• Наконец, Игра может происходить в виде турнира на выбывание (пока не реализовано).

Очередь является эталонной, если с нее начинается Игра. Внутри Игры могут происходить пропуски ходов или внеочередные ходы, то есть кроме эталонного, существует актуальный экземпляр Очереди для каждой Игры в каждый момент! Поэтому экземпляр класса Очередь имеет атрибут is_reference=True, если это эталонный экземпляр, и атрибуты, обозначающие моменты для конкретной игры:

• game: экземпляр Игры,

• n_round: номер раунда Игры,

• player: Игрок, после которого произошло изменение,

• is_next_round: True, если данный экземпляр очереди сохраняется на следующий раунд

# Библиотека itertools позволяет получить комбинации и перестановки списка
import itertools

class Queue(Mixin):
    """Очередь Игроков в порядке ходов, последовательность действий Игроков.

    Parameters
    ----------
    priority: list , по умолчанию пустой список
        Список имен или ссылок на экземпляры Игроков (трансформируются в имена)
        в порядке очередности хода. Если Игра одновременная, 
        то Очередь используется как список Игроков, принимающих участие
        TODO Можно задать название Группы или ссылку на экземпляр Группы
        TODO Можно задать экземпляр Dice, определяющий список Игроков

    parties: int
        Игра по партиям, то есть Игроки играют группами, переходя из группы в группу.
        Если играют парами, parties=2, тройками - parties=3 и т.д. 
     
    parties_type: str
        Если задан, то определяет, как соствляются партии. 
        'combinations' - получить комбинации,
        'combinations_with_myself' - комбинации с возможностью повторения, 
        'permutations' - перестановки
        Количество Игроков по партиям определяется parties. Пары, если parties не задано.
        parties_type  можно присвоить экземпляр Dice, выбирающий нескольких случайных игроков
    
    max_parties: int 
        Ограничить количество партий, по умолчанию не ограничено.
        Если parties_type присвоен экземпляр Dice, то по умолчанию max_parties = 1
        Рекомендуется задавать, если parties_type присвоен экземпляр Dice
    """

    all = dict()  # Словарь всех Очередей

    def __init__(self, priority: list = None, 
                 parties: int = None,
                 parties_type: str = None, 
                 max_parties: int = None, 
                 is_reference:bool = True,
                 game = None,
                 n_round: int = None,
                 game = None, 
                 is_next_round:bool = None,
                 **kwargs):
        
        self.priority = list()
        self.max_parties = max_parties
        if not priority is None:
            for player in priority:
                if isinstance(player, str):
                    self.priority.append(player)
                elif isinstance(player, Player):
                    for name, value in Player.all.items():
                        if player == value:
                            self.priority.append(name)
                else:
                    raise ValueError 
        
        self.parties = parties
        self.parties_type = parties_type
        self.start_priority = self.priority

        if (not self.parties_type is None) and (self.parties is None):
            self.parties = 2
        if self.parties_type == 'combinations':
            self.priority = [i for i in itertools.combinations(self.priority, self.parties)]
        elif self.parties_type == 'combinations_with_myself':
            self.priority = [i for i in 
                             itertools.combinations_with_replacement(self.priority, self.parties)]
        elif self.parties_type == 'permutations':
            self.priority = [i for i in itertools.permutations(self.priority, self.parties)]
        else:
            pass

        self.is_reference = is_reference
        self.game = game
        self.n_round = n_round
        self.is_next_round = is_next_round

        
        super().__init__(**kwargs,**{'priority': self.priority,
                                     'parties': self.parties,
                                     'parties_type': self.parties_type,
                                     'max_parties': self.max_parties,
                                     'is_reference': self.is_reference,
                                     'game': self.game,
                                     'n_round': self.n_round,
                                     'is_next_round': self.is_next_round
                                    })

Создадим нескольких игроков и очередь, состоящую из партий по 2 игрока, полученных перестановками:

# Создадим игроков
p1 = Player(name='Кая', about='Из коробки, дефолтные настройки')
p2 = Player()
p3 = Player()
p4 = Player(name='Дамилола', characteristics={'Профессия': 'Пилот'})

# Создадим очередь, состоящую из партий по 2 игрока, 
# полученных перестановками:
q1 = Queue(priority=Player.all, parties=2, parties_type='permutations')

# Посмотрим очередь игроков:
q1.priority

[('Кая', 'Player_0'),
 ('Кая', 'Player_1'),
 ('Кая', 'Дамилола'),
 ('Player_0', 'Кая'),
 ('Player_0', 'Player_1'),
 ('Player_0', 'Дамилола'),
 ('Player_1', 'Кая'),
 ('Player_1', 'Player_0'),
 ('Player_1', 'Дамилола'),
 ('Дамилола', 'Кая'),
 ('Дамилола', 'Player_0'),
 ('Дамилола', 'Player_1')]

На сегодня пока всё, следите за следующими статьями серии!