• Stars
    star
    808
  • Rank 56,429 (Top 2 %)
  • Language
    Java
  • License
    MIT License
  • Created about 5 years ago
  • Updated over 1 year ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

A Java implemented Texas holdem and short deck Solver

TexasHoldemSolverJava

release license

README English | 中文

🚨 This project still works but it's no longer maintained. Please check our latest C++ version TexasSolver.

Introduction

A open sourced, efficient Texas Hold'em and short deck solver. See this Introduction video for more.

algs

This is a java-based Texas Hold'em solver, fully open source, have a pio-solver-like gui and supports cross-language calls (supports python and command-line calls by default). Support standard Texas Hold'em and it's popular variant short-deck.

Similar to common commercial Texas Hold'ems solvers such as piosolver, TexasHoldemSolverJava focusing on solving post-flop situations, and it's result is aligned with piosolver. On turn and river it's speed is even faster than piosolver, but on flop is slower than piosolver.

Features:

  • Efficient, turn and river calculation speed exceeds piosolver
  • Accurate, the results are almost the same as piosolver
  • Fully open source and free
  • Have a simple gui
  • Support standard Texas Hold'em and it's popular variant short-deck
  • Focus on post-flop situations
  • Supports command line and python calls

This project is suitable for:

  • high-level Texas Hold'em players
  • Scholars in the field of incomplete information games

install

Install 64bit Java Runtime Environment first.

Download the release package unzip it, you will get a folder look like this:

--- Solver
 |- resources
 |- java_interface.py
 |- RiverSolver.jar
 |- riversolver.sh

Install is done. It's that simple.

RiverSolver.jar is the solver program file,java_interface.py is the sample code for calling solver trough python calls. It contains the following test cases:

  • testcase for short flop situation
  • testcase for short turn situation
  • testcase for short river situation
  • testcase for holdem turn situation
  • testcase for holdem river situation

riversolver.sh contains sample code for command line calls.

after download the release package, run python3 java_interface.py to run all the testcases.

In addition to downloading the software itself, Texas Holdem solver Java also relies on JRE 11.0.2 as it's e runtime. Please install Java JRE 11.0.2 in advance.

Usage

gui

Make sure the right version of java is installed in your computer(64bit,java 10.x / java 11.x)

Double click the riversolver.jar to open gui.

python api

Additional python requirements should also be installed through pip:

pip3 install jpype
pip3 install numpy
pip3 install yaml
pip3 install networkx
pip3 install matplotlib

Althrough written in java. TexasHoldemSolverJava is by default called through python.

Sample code involves python calls can be found in java_interface.py. Here we briefly introduce the procedure of calling the solver and some basic parameters.

When running python codes, make sure resource folder and jar file(can be downloaded) are placed in work dir. After that import all dependencies through the code below:

from jpype import *
import yaml
import numpy as np
import sys
sys.path.append("resources")
from python.TreeBuilder import *

Next, start the JVM and load the solver class:

startJVM(getDefaultJVMPath(), "-ea", "-Djava.class.path=%s" % "./RiverSolver.jar")
PokerSolver = JClass('icybee.solver.runtime.PokerSolver')

Initialize PokerSolver class, PokerSolver is used to do the optimal strategy finding(solving) job.

ps_holdem = PokerSolver("Dic5Compairer",
    "./resources/compairer/card5_dic_sorted.txt", # Load hand compair dictionary file. Holdem and shortdeck use different dictionary file
    2598961, # valid line of dictionary file
    ['A', 'K', 'Q', 'J', 'T', '9', '8', '7', '6', '5', '4', '3'], # figure of cards
    ['h', 's', 'd', 'c'] # pattern of cards
)

Like in piosolver, when solving a specific holdem/shortdeck scenario (for example in turn), a game tree should be built first:

# Load some general rules of texas holdem. e.g. you can check/raise after a check, you can raise/call/fold after a raise.
with open('resources/yamls/general_rule.yaml') as fhdl:
    conf = yaml.load(fhdl)
# Use RulesBuilder to convert these rules to game tree.
rule = RulesBuilder(
    conf,
    current_commit = [2,2], # current bets of both players(p0 and p1)
    current_round =  3, # current round of the game, 1 for preflop, 2 for flop,3 for turn,4 for river
    raise_limit = 3, # the limit of numbers of raises
    check_limit = 2, # how many times you can check, in 2-player texas holdem, it's 2
    small_blind = 0.5, # amount of small blind (SB)
    big_blind = 1, # amount of big blind (BB)
    stack = 10, # the amount of chips for both sides. If two player have different chip amount, fill in the smaller number here. For example player1 have $100 chip and player2 have $150, fill in 100 here.
    bet_sizes = ["0.5_pot","1_pot","2_pot","all-in"], # bet sizes and raise sizes considered in the game tree,can be number e.g. 1,1.5 or in the proportion of the pot e.g. "0.5_pot","1_pot"
)
# build the game tree according to the settings above
gameTree = PartGameTreeBuilder(rule)
# save the game tree to disk
gameTree.gen_km_json("./.tree.km",limit=np.inf,ret_json=True)

Read the game tree in solver and construct the game tree in memory.

ps_holdem.build_game_tree("./.tree.km")

Input all the parameters and start solving.

result = ps_holdem.train(
    "AA:0.5,KK:0.9,QQ:0.8,97,96,87,86,76", # player1's range, seperate by ','; you can write range in two ways: (1) "KK:0.5" stands for player have K-pair weighted 0.5 (2) "KK" stands for player have a K-pair weighted 1
    "AA:0.8,KK:0.2,QQ:0.3,86,76:0.9", # player2's range
    "Kd,Jd,Td,7s", # the revealed public cards. In turn there are four. 
    50, # the iterations for cfr algorithm
    10, # the gap to print exploitability
    False, # whether to print debug info
    True, # whether to use parallel technology
    "output_strategy.json", # for to write output strategy. When set to None the strategy json will be returned in result of this method.
    "log.txt", # log file 
    "discounted_cfr", # the solver algorithm ,support "cfr" vanilla cfr algorithm, "cfr_plus" faster cfr+ algorithm,"discounted_cfr" discounted cfr ++ algorithm we proposed here
    "none", # whether to use monte coral sampling algorithm,useful when the game tree is extremely big,got two options: "none" means do not use monte coral algorithm, "public" use public chance monte coral algorithm
    -1, # threads number ,1 for single thread,2 for two threads...,-1 means use all possible cpu
    1, # action fork probability, relevant to solver multithread performance ,should be between 0~1
    1, # chance fork probability, relevant to solver multithread performance ,should be between 0~1
    1, # fork every tree depth, relevant to solver multithread performance , should be > 0
    4, # fork minimal size, relevant to solver multithread performance , should be > 0
)

The solver will start to work after executing the above code. Time required for solving is affected by game tree size, range complicity, and computer hardware. In my mac book pro, river can be solved in less than 1 second, turn can be solved usually within 10 seconds.

command line api

Please refer to code in riversolver.sh in release package. The parameters are the same to the python code.

Reading the Solver's output

When running, the solver would generate logs like this:

Iter: 0
player 0 exploitability 1.653075
player 1 exploitability 2.146374
Total exploitability 47.493111 precent
-------------------
Iter: 11
player 0 exploitability 0.040586
player 1 exploitability 0.322102
Total exploitability 4.533607 precent
-------------------
......
-------------------
Iter: 41
player 0 exploitability -0.114473
player 1 exploitability 0.168947
Total exploitability 0.680923 precent
.Using 4 threads

Be ware how the exploitability converges, normally a strategy with an exploitability < 0.5 is more than enough to serve as an optimal strategy.

An output_strategy.json file will be generated by the solver after solving. It can be read by any language and you can directly opened by firefox(yes, the famous browser). The size of the file varies between a few Kb to dozens of Gb.

If opened by firefox, you are excepted to see something looks like this:

algs

player : 1

This field indicates player1 is making his move.

actions:
    0: "CHECK"
    1: "BET 4.0"

"actions" field contains player1's moves considered by the solver.

Strategy field contains optimal strategy for player1 with different hands:

algs

Each specific item of strategy contains the "optimal strategy" of specific hand calculated by the solver.

algs

For example, the figure above represents that when player 1 gets the hand of qd7c (square Q, plum 7), the optimal strategy is to check with 34% probability and bet with 65% probability.

Compile the release package

Normally compiling the release package manually is not required. It can be directly downloaded here However if you intend to modify this project, recompiling is required. TexasHoldemSolverJava is a IDEA project, an IDEA environment is required to compile the release package, if you want to compile the release package, please follow the following instruction:

  1. install IntellIJ IDEA
  2. download TexasHoldemSolverJava from github and load to IntellIJ IDEA
  3. press build -> build project to compile the projet from source
  4. press build -> build artifacts -> all artifacts -> build to generate the release package
  5. the release package can be found in the out folder in project root

benchmarks

The speed compair with piosolver listed below, turn and river's speed is comparable with piosolver , flop is much slower due to game tree and lack of optimization.

flop sample turn sample river sample
piosolver 7.91s 1.5s 0.56s
TexasHoldemSolverJava 98s 4.21s 0.06s

Input of the above benchmark and result compair with piosolver is listed below.

flop sample turn sample river sample
input (in text format) flop turn river
input (in image format) flop turn river
result compair flop turn river

The slight different between Piosolver and TexasHoldemSolverJava is due to different tree construction logic and insufficient CFR converge for both software.

Algorithm

As shown in the figure below, thanks to the implementation of the latest algorithm variant discounted CFR ++, algorithm used in this project can be a lot faster than traditional algorithms such as CFR +. algs

c++ version

If you somehow feel our java version is not fast enough,here is a ported c++ version ,c++ version is faster than java version in turn and river, however still contains certain problems:

  • supports only Linux machine
  • manually compile is reqiured before use
  • c++ version's code is not well optimized, it's slower 5x faster than the java version on flop.

License

MIT © bupticybee

Contact

[email protected]

More Repositories

1

TexasSolver

🚀 A very efficient Texas Holdem GTO solver ♠️♥️♣️♦️
C++
1,757
star
2

ChineseAiDungeonChatGPT

中文版的ai地牢,直接使用的openai的ChatGPT api作为讲故事的模型。
Python
1,391
star
3

icyChessZero

中国象棋alpha zero程序
Jupyter Notebook
376
star
4

ChineseAiDungeon

中文版ai地牢,基于清源CPM fineutne
Python
236
star
5

elephantfish

elephantfish: 一个只有124行的中国象棋引擎
Python
233
star
6

FastLoRAChat

Instruct-tune LLaMA on consumer hardware with shareGPT data
Jupyter Notebook
121
star
7

XQPy

象棋巫师(非官方)python实现
JavaScript
68
star
8

AlphaNLHoldem

An unoffical implementation of AlphaHoldem. 1v1 nl-holdem AI.
Jupyter Notebook
65
star
9

ByrBbsMirror

北邮人论坛镜像源代码
Python
39
star
10

icyface_offline

offline part of icyface
Jupyter Notebook
30
star
11

icytranslate_offline

The offline part of icytranslate(a english-chinese translate platform) ,the output of this project should be a translate model
Jupyter Notebook
19
star
12

icyElephant

a chinese chess engine using conv neural network with zero look-ahead
Jupyter Notebook
19
star
13

gym_chinese_chess

中国象棋gym环境
Jupyter Notebook
12
star
14

AiDungeonChatGPT

AI-Dungeon like Game, directly uses openai's ChatGPT api as a storytelling model.
Python
11
star
15

icyface_api

rest api of icyface
Python
8
star
16

ChineseChessMuzero

使用Muzero算法进行中国象棋对弈
Jupyter Notebook
8
star
17

icytranslate_api

restful api of icytranslate (an opensource english - chinese translate platform)
Jupyter Notebook
7
star
18

icycloud

An docker based IAAS platform
JavaScript
6
star
19

mandarin_recognition

chinese mainland madarin speech recognition neural networks
Jupyter Notebook
5
star
20

icygo

a cnn based go engine
Jupyter Notebook
5
star
21

icyface_website

JavaScript
5
star
22

FastChat

FastChat clone
Python
4
star
23

shisanshui_ai

十三水AI,使用Deterministic CFR解决十三水问题
C++
4
star
24

dark-lora

dark version of a chat LLM
Jupyter Notebook
4
star
25

deuces

A python3 port of https://github.com/worldveil/deuces , a pure python poker hand evaluator
Python
4
star
26

icytranslate_website

the website of icytranslate, a english-chinese translate system
CSS
3
star
27

texas_holdem

德州扑克 通用solver构建中进行的一些实验
Jupyter Notebook
2
star
28

rainfall_prediction

Jupyter Notebook
2
star
29

texassolver_page

webpage of texas solver
HTML
2
star
30

simple_ocr

Jupyter Notebook
2
star
31

Object-detection

Using tensorflow to build a series of object detection networks, and discuss each network's performance
Jupyter Notebook
2
star
32

en2ch_translate

a demo that translates english to chinese
Jupyter Notebook
1
star
33

Lesson1_simple_face

face recognition using hisgram,HOG,LBP,CNN, etc, a brief code history of facial recognition
Jupyter Notebook
1
star