Казино На Питоне

Что такое моделирование методом Монте-Карло?

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

Игра в кости

В этой игре будут задействованы 2 шестигранных кубика. Для выигрыша игроку требуется выбросить одинаковое число на обоих кубиках. Шестигранный кубик имеет 6 возможных исходов (1, 2, 3, 4, 5 и 6). С двумя кубиками 36 возможных исходов (1 и 1, 1 и 2, 1 и 3 и т. д., или 6 х 6 = 36 вариантов). В этой игре у заведения больше шансов на победу (30 исходов против 6 у игроков), следовательно, у заведения значительное преимущество.

Предположим, игрок начинает с баланса в 1000$ и готов проиграть все, поэтому ставит 1$ на каждый бросок (оба кубика) и решает сделать 1000 бросков. Предположим, что заведение щедрое и выплата будет в 4 раза больше ставки, когда игрок выигрывает. Например, если игрок выиграет первый бросок, баланс увеличится на 4$, и раунд закончится с 1004$. Если чудом получится выиграть серию из 1000 бросков, то итого получится 5000$. В случае каждого неудачного раунда получится 0$.

Импорт библиотек Python

Смоделируем игру, чтобы выяснить, сделал ли игрок правильный выбор. Начнем код с импорта необходимых библиотек Python: из и . Для визуализации результатов будет использоваться библиотека , для моделирования броска шестигранной игральной кости – .

Функция броска кубиков

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

Входные данные и отслеживаемые переменные

Каждое моделирование методом Монте-Карло требует знание входных данных и информации, которую требуется получить. Входные данные определены, когда описывалась игра. Количество бросков за игру 1000 раз, сумма за бросок 1$. В дополнение требуется определить – сколько раз игра будет моделироваться. В качестве счетчика Монте-Карло используем переменную . Чем больше это число, тем точнее прогнозируемая вероятность соответствует истинному значению.

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

Настройка фигуры

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

Моделирование Монте-Карло

В коде ниже 2 цикла: внешний, который перебирает заданное кол-во симуляций (10000) и вложенный, который запускает каждую игру (1000 бросков). Перед запуском каждого цикла инициализируется:

• баланс игрока как 1000$(в виде списка для построения графиков);
• количество бросков и выигрышей.
  

Цикл будет моделировать игру на 1000 бросков. Внутри этого цикла бросаются кости, используя логическую переменную, возвращаемую функцией для определения результата. Если кости одинаковые – в список баланса добавляется 4-кратная ставка и выигрыш к счету игрока. Если кости разные – вычитается ставка из списка баланса. В конце каждого броска добавляем счетчик в список .

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

Получение результатов

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

Анализ результатов

Сделаем вывод из результатов. Из рисунка выше возможно определить, что игрок редко получает прибыль после 1000 бросков. Средний конечный баланс 10000 симуляций составляет 833,66$ (из-за рандомизации, возможны различия результатов). Казино остается в выигрыше даже, если выплачивает в четыре раза больше при победе игрока.

Также заметим, что вероятность выигрыша составляет 0.1667 или 1/6. Выше было отмечено, что у игрока 6 выигрышных исходов из 36 возможных. Используя эти 2 числа ожидаемо, что игрок выиграет 6 из 36 бросков, или 1/6 бросков, что соответствует прогнозу Монте-Карло.

***

Материалы по теме

Интересно, перейти к каналу

Hello, world!

Привет, Хабр! Меня зовут Михаил, я учусь на втором курсе Южно-Уральского государственного Университета и одни из самых любимых вещей в моей жизни - это программирование и азартные игры.

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

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

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

P.S. Данная статья не является рекламой азартных игр или конкретного сайта. Автор неоднократно проигрывал крупные суммы и не рекомендует никому связываться с казино или ставками.

Представляем вам злодея

В качестве противника будет выступать популярный сайт-рулетка по Counter Strike: Global Offensive - CSGOFAST. На этом сайте присутствует более десяти видов азартных игр, а в качестве валюты используются скины на оружия из игры CS:GO.

Мы будем пытаться обыграть евро рулетку, вернее её аналог c сокращенным количеством номеров. Выбор именно этого сайта обусловлен несколькими причинами, одна из них - личные счеты:) Об остальном будет сказано далее.

Правила игры

Руле́тка  — азартная игра, представляющая собой вращающееся колесо с 36 секторами красного и чёрного цветов и 37-м зелёным сектором «зеро» с обозначением нуля. Игроки, играющие в рулетку, могут сделать ставку на выпадение шарика на цвет (красное или чёрное), чётное или нечётное число, диапазон (1—18 или 19—36) или конкретное число. Крупье запускает шарик над колесом рулетки, который движется в сторону, противоположную вращению колеса рулетки, и в конце концов выпадает на один из секторов. Выигрыши получают все, чья ставка сыграла (ставка на цвет, диапазон, чётное-нечётное или номера).

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

Как работает рандом

В начале раунда(то есть до ставок) на стороне сайта выбирается случайное число от 0 до 1. По окончании раунда оно домножается на 15 и округляется до целого в меньшую сторону. Получившееся число - номер победного сектора. Чтобы сайт не подкручивал рулетку как угодно ему, с самого начала раунда нам доступен SHA-256 хеш случайного числа, которое выбрал сайт, а после раунда и само число, соответственно пользователь может самостоятельно пропустить его через SHA-256 алгоритм и убедиться в честности.

Сайт не может подкрутить, так как победный цвет известен до ставок.

P.S. Для тех, кто не знаком с шифрованием, SHA-256 это такая штука, которая преобразует одну последовательность символов в другую, при этом в обратную сторону так сделать довольно тяжело(практически невозможно). В этом и прикол.

Перейдем к делу

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

Мы будем использовать Python и библиотеку Requests-HTML, обычный requests не подойдет, поскольку для доступа к результатам игр нужно предварительно выполнить на странице весь JavaScript. Результаты будем записывать в .csv файлы. Также я не стал заморачиваться над причесыванием данных во время сбора, ведь гораздо легче сделать это парой команд из Pandas.

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

Парсер будет загружать HTML страницу, рендерить весь JavaScript, выбирать текст из контейнера '.history-wrap'(он содержит результаты 50 последних игр - то, что нам надо) а затем возвращать удобный список из результатов игр.

Аналогичным образом работает и вторая функция. Иногда случается момент, когда на странице отсутствует '.game-bets-header', поэтому добавлена проверка.

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

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

Поиграем

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

Я выделил 3 консервативных метода игры:

1) Игра без стратегии

Я просто полагался на удачу и интуицию, угадывая числа. На поле присутствует 7 черных, 7 красных и 1 зеленый сектор. Значит, при ставке на красное/черное мы имеем вероятность победы 7/15 или же 0.466. По факту так играет большинство

Сыграв 100 игр(без ставок), я угадал верно 45/100 выпадений, что уже довольно близко к аналитически вычисленному значению. Забегая вперед, построим графики с помощью matplotlib и Pandas.

Зеленое - я угадал цвет, красное - я ошибся, серое - правильный ответ при моих ошибках. Стоит заметить, что precision и recall зеленого составляют два ноля:) Иначе говоря, ни один раз, предсказав ноль, я не оказался прав и не угадал ни одного действительно выпавшего ноля

2) Мартингейл

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

Пример: 1 красное-проиграл-2 красное-проиграл-4 красное-проиграл-8 красное- выйграл(окупился на 1 единицу)- 1 красное-... Тогда выйгрыш всегда будет покрывать потери, а еще и давать прибыль в размере первой ставки.

Пусть S - начальная сумма.

Сформулировать это математически можно так: для того, чтобы сделать n ставок, нужно потратить S*(2^(n) - 1) валютных единиц. При этом вероятность проиграть будет выглядеть так: 0.54 ^ n. Данная стратегия не терпит единого поражения, поскольку оно означает потерю баланса. Главный минус - сумма растет в два раза с каждой ставкой. С другой же стороны очень сложно поверить в выпадение, допустим, 20 черных подряд без подкруток(на деле автор видел 23 черных подряд). Измусоленная тема - ошибка игрока.

Сделаем вывод о данной стратегии во время анализа.

Посмотрим на сумму ставки при количестве игр n:

Иначе говоря, играя по Мартингейлу с запасом на 20 пройгрышей, вы будете рисковать миллионом ради одного рубля в почти самом плохом случае(в самом плохом вы проиграете:)). Хочу напомнить, что одна игра идет порядка 40 секунд, а вы будете получать по 1 единице прибыли с каждой игры. Для реальной прибыли надо начинать хотя бы с 10 рублей, и иметь в запасе 10 миллионов на запас из 20 игр.

3) Мартингейл++

До этой стратегии я(как и миллион других гениев-игроманов) додумался сам. Ждем, пока на рулетке выпадет 6-7 одинаковых цветов на холостом ходу, а затем начинаем ставить по Мартингейлу.

Проблема в том, что если играть по 10 рублей и ждать выпадение 7 цветов в ряд, вы скорее состаритесь, чем станете миллионером.

Тем временем, наблюдения уже собрались.

Приведем данные в порядок

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

Денежный датасет

Общий датасет

Теперь мы объединим 2 датасета в один

Исследование

2 вещи, которые всегда меня интересовали - какое максимальное количество раз какой-то цвет не выпадал и сколько казино получает прибыли. Будем добираться до сути.

Выяснили, что красное выпадало подряд 11 раз, черное 12, зеленое - 3.

Также нужно посчитать кол-во игр, которое какой-то цвет, наоборот, не выпадал.

Красное не выпадало 16 игр подряд, черное 17, зеленое 95(!). Внимание на графики.

Я могу сделать для себя какие-то выводы. Еще совсем недавно я пытался ждать 15-20 игр без зеленого, а затем начинал на него ставить до победного. Зная, что частенько зеленое не выпадает и 30+ раз, больше играть я по такой стратегии я не буду(хотя, кого я обманываю...).

И самое главное - Мартингейл. 17 раз подряд. Рискуем 131 тысячей денежных единиц ради одной. Если же начинать играть с середины, допустим, с восьмого выпадения - будем рисковать 1023 единицами ради одной. И никто не гарантирует, что больше 17 раз подряд серии не будет. Стоит ли оно того? Решает каждый сам.

Далее - прибыль сайта

За одиннадцать тысяч игр, с учетом пропущенных, сайт получил прибыль в размере 62129.7 долларов или 4541059.78 рублей по текущему курсу. Я собирал данные 10 дней. Неплохо, однако...

Ну, напоследок взглянем на то, как выглядит график числа раунда за 200 игр.

Увидеть какие-то паттерны на данном графике невооруженным глазом невозможно.

Построение моделей

Я решил использовать 3 вида входных/выходных данных модели:

1) Предыдущие цвета -> следующий цвет

2) Предыдущие числа -> следующий цвет

3) Предыдущие числа -> следующее число

Создадим колонки с предыдущими выпадениями чисел(иначе говоря лагами)

Аналогичным образом будем создавать и лаги цветов для будущих моделей.

Теперь первую колонку(без задержек) можно использовать в качестве вектора ответов, а 50 колонок лагов в качестве матрицы признаков.

Перебор

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

Итого опробовав 5 регрессий, а затем и пару полиномиальных и все это с разными гиперпараметрами, добиться точности выше 0.48 не удалось(да и такая точность скорее всего получилась из-за удачно подобранного random seed, т.е. случайного фактора)

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

Neural Networks

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

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

Внимание на последние эпохи:

Внезапно(или нет?) количество потерь сократилось до 0.33. Ура? Нет. Наша модель просто переобучилась и заучила ответы на тренировочной выборке. Посчитав accuracy, получаем 0.45, что даже хуже, чем у полиномиальной регрессии...

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

Заключение

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

Ссылка на ноутбук в Colab

Ссылка на данные

А на этом я с вами прощаюсь. Надеюсь, не навсегда.

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

Что проверяем

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

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

Мы сделаем три модели рулетки:

Но это в теории. Как получится на практике — сейчас проверим.

Графики

Чтобы построить графики, нам понадобятся две библиотеки — Plotly и Pandas. 

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

Чтобы вся эта магия с данными работала и графики обрабатывались правильно, для Plotly нужна библиотека Pandas. Она отвечает за математику, анализ и обработку всех чисел на графике.

Устанавливаются библиотеки так:

Эти команды можно запустить прямо в терминале VS Code, если вы пишете код в нём, а если нет — то в командной строке компьютера.

Подготовка

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

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

Напишем это на Python:

Три стратегии с матожиданиями

В каждой стратегии будем ставить на цвет — красное или чёрное. Чтобы понять, сыграла ставка или нет, мы каждый раз будем брать случайное число от 1 до 37: 18 чёрных, 18 красных и зеро. Чтобы было проще, пусть числа от 1 до 18 у нас будут чёрные, с 19 по 36  — красные, а 37 будет зеро. 

Первая стратегия: берём всё как есть и просто бросаем шарик. Если выпало чёрное — мы выиграли. В этой стратегии у нас 18 выигрышных вариантов и 19 проигрышных, поэтому матожидание будет отрицательным.

Вторая стратегия: убираем зеро. У нас получается по 18 чёрных и красных чисел, и вероятность выиграть — ровно 50 на 50. Это даёт нам нулевое матожидание.

Третья: убираем зеро и одно красное число, чтобы было 18 чёрных и 17 красных. Так как вероятность попасть на чёрное выше, чем на красное, то матожидание будет положительным.

👉 Когда будете читать код, обратите внимание на такую строку: . Дело в том, что Python работает с диапазоном range() так: первое число входит в рабочий диапазон, а конечное — нет. Поэтому, чтобы нам проверить, попало ли наше число в диапазон от 1 до 18 включительно, нам нужно указать range(1,19).

Если мы запустим этот код, то в консоли увидим результат для каждого матожидания:

Кажется, что все три варианта дают примерно одинаковый результат, но на самом деле в первом случае вы останетесь без денег, а в третьем — разбогатеете. Чтобы было нагляднее — построим графики.

Строим графики

Для графиков мы используем библиотеку Plotly и рисуем сразу все три графика на одном поле — это даст нам наглядность и понимание, к чему приводит разное матожидание. Чтобы было понятно, какой график отвечает за какую стратегию, мы их подпишем:

Теперь посмотрим на тот же результат, который у нас получился, но в виде графиков:

Синяя линия — это баланс нашей первой игры с отрицательным матожиданием. Мы предсказуемо всё проиграли.

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

Зелёная линия — наш баланс при положительном матожидании. Мы выигрывали чаще, чем проигрывали, поэтому удвоили нашу стартовую сумму.

Что дальше

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

Любишь Python? Зарабатывай на нём!

Изучите самый модный язык программирования и станьте крутым бэкенд-разработчиком. Старт — бесплатно.

Попробовать бесплатно

Задумка

Программная реализация

1. Ставим 100;
2. Если ставка выигрывает — снова ставим сто. Если проигрывает — ставим в два раза больше. Выйти в +?!

Нужна помощь с одноруким бандитом(казино)

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

import random
import time

while True:
try:
credit = int(input('Введи нужное тебе колличество кредитов: '))
print ('И так! Игра началась. У тебя есть ' + str(credit) +
' единиц, с помощью них ты можешь делать ставки')
cash = int(input('Введи ставку: '))
except:
print ('ВВЕДИ ЦИФРЫ')
try:
while credit > 0:
print('Отлично, ставка сделана!')
time.sleep(0.1)
print('Игра началась...')
time.sleep(1)

m = random.randint(1, 3)
o = random.randint(1, 3)
n = random.randint(1, 3)
e = random.randint(1, 3)

print(m, o, n, e)
credit = credit - cash
if m == 1 and o == 1 and n == 1 and e == 1 or m == 2 and o == 2 and n == 2 and e == 2 or m == 3 and o == 3 and n == 3 and e == 3 :

b = random.randint(2, 2000)
print(' ВЫ ВЫИГРАЛИ ' + str(cash * b))
credit = credit + (cash * b)
time.sleep(2)
y = input('Введи "y" если хочешь сменить ставку: ')
time.sleep(2)
if y == 'y':
cash = int(input('Введи ставку: '))
else:
continue
time.sleep(2)
print('Oсталось кредитов ' + str(credit))
input('Press enter...!')
except:
print('ERROR ENTER')