Leduc Holdem
2021年11月21日Register here: http://gg.gg/wyxye
Expert-Level Artificial Intelligence in Heads-Up No-Limit PokerLinks
Mar 02, 2020 Leduc Hold’em is a toy poker game sometimes used in academic research (first introduced in Bayes’ Bluff: Opponent Modeling in Poker). It is played with a deck of six cards, comprising two suits of three ranks each (often the king, queen, and jack — in our implementation, the ace, king, and queen). Leduc hold ’em: The results of the various algorithms playing against the player are shown in Figure 2. Since for Leduc hold’em we can explicitly compute the best possible response against any strategy, that result is shown in the top line. Needless to say, none of the Bayesian strategies achieve this win rate. Karla Leduc Poker, 5 card draw free online, joc slots cu fructe, genting casino feng shui Win big prizes only available on Aboutslot. Check out our current giveaway.
Twitch | YouTube | Twitter
Downloads & Videos | Media Contact
Special UH-Leduc-Hold’em Poker Betting Rules: Ante is $1, raises are exactly $3. Each player can only check once and raise once; in the case a player is not allowed to check again if she did not bid any money in phase 1, she has either to fold her hand, losing her money, or raise her bet. Only player 2 can raise a raise.
DeepStack bridges the gap between AI techniques for games of perfect information—like checkers, chess and Go—with ones for imperfect information games–like poker–to reason while it plays using “intuition” honed through deep learning to reassess its strategy with each decision.
With a study completed in December 2016 and published in Science in March 2017, DeepStack became the first AI capable of beating professional poker players at heads-up no-limit Texas hold’em poker.
DeepStack computes a strategy based on the current state of the game for only the remainder of the hand, not maintaining one for the full game, which leads to lower overall exploitability.
DeepStack avoids reasoning about the full remaining game by substituting computation beyond a certain depth with a fast-approximate estimate. Automatically trained with deep learning, DeepStack’s “intuition” gives a gut feeling of the value of holding any cards in any situation.
DeepStack considers a reduced number of actions, allowing it to play at conventional human speeds. The system re-solves games in under five seconds using a simple gaming laptop with an Nvidia GPU.The first computer program to outplay human professionals at heads-up no-limit Hold’em poker
In a study completed December 2016 and involving 44,000 hands of poker, DeepStack defeated 11 professional poker players with only one outside the margin of statistical significance. Over all games played, DeepStack won 49 big blinds/100 (always folding would only lose 75 bb/100), over four standard deviations from zero, making it the first computer program to beat professional poker players in heads-up no-limit Texas hold’em poker. Casino games no download no registration.Games are serious business
Don’t let the name fool you, “games” of imperfect information provide a general mathematical model that describes how decision-makers interact. AI research has a long history of using parlour games to study these models, but attention has been focused primarily on perfect information games, like checkers, chess or go. Poker is the quintessential game of imperfect information, where you and your opponent hold information that each other doesn’t have (your cards).
Until now, competitive AI approaches in imperfect information games have typically reasoned about the entire game, producing a complete strategy prior to play. However, to make this approach feasible in heads-up no-limit Texas hold’em—a game with vastly more unique situations than there are atoms in the universe—a simplified abstraction of the game is often needed.A fundamentally different approach
DeepStack is the first theoretically sound application of heuristic search methods—which have been famously successful in games like checkers, chess, and Go—to imperfect information games.
At the heart of DeepStack is continual re-solving, a sound local strategy computation that only considers situations as they arise during play. This lets DeepStack avoid computing a complete strategy in advance, skirting the need for explicit abstraction.
During re-solving, DeepStack doesn’t need to reason about the entire remainder of the game because it substitutes computation beyond a certain depth with a fast approximate estimate, DeepStack’s ’intuition’ – a gut feeling of the value of holding any possible private cards in any possible poker situation. Jackpot cash casino instant play.
Finally, DeepStack’s intuition, much like human intuition, needs to be trained. We train it with deep learning using examples generated from random poker situations.
DeepStack is theoretically sound, produces strategies substantially more difficult to exploit than abstraction-based techniques and defeats professional poker players at heads-up no-limit poker with statistical significance.DownloadPaper & SupplementsHand HistoriesMembers (Front-back)
Michael Bowling, Dustin Morrill, Nolan Bard, Trevor Davis, Kevin Waugh, Michael Johanson, Viliam Lisý, Martin Schmid, Matej Moravčík, Neil BurchLeduc Hold’emlow-variance Evaluation
The performance of DeepStack and its opponents was evaluated using AIVAT, a provably unbiased low-variance technique based on carefully constructed control variates. Thanks to this technique, which gives an unbiased performance estimate with 85% reduction in standard deviation, we can show statistical significance in matches with as few as 3,000 games.Abstraction-based Approaches
Despite using ideas from abstraction, DeepStack is fundamentally different from abstraction-based approaches, which compute and store a strategy prior to play. While DeepStack restricts the number of actions in its lookahead trees, it has no need for explicit abstraction as each re-solve starts from the actual public state, meaning DeepStack always perfectly understands the current situation.Professional Matches
We evaluated DeepStack by playing it against a pool of professional poker players recruited by the International Federation of Poker. 44,852 games were played by 33 players from 17 countries. Eleven players completed the requested 3,000 games with DeepStack beating all but one by a statistically-significant margin. Over all games played, DeepStack outperformed players by over four standard deviations from zero.
Heuristic Search
At a conceptual level, DeepStack’s continual re-solving, “intuitive” local search and sparse lookahead trees describe heuristic search, which is responsible for many AI successes in perfect information games. Until DeepStack, no theoretically sound application of heuristic search was known in imperfect information games.’,’resolveObject’:’,’resolvedBy’:’manual’,’resolved’:true}’>’,’resolvedBy’:’manual’,’resolved’:true}’>’,’resolveObject’:’,’resolvedBy’:’manual’,’resolved’:true}’>Latest version
Released:
A Toolkit for Reinforcement Learning in Card GamesProject description
RLCard is a toolkit for Reinforcement Learning (RL) in card games. It supports multiple card environments with easy-to-use interfaces. The goal of RLCard is to bridge reinforcement learning and imperfect information games. RLCard is developed by DATA Lab at Texas A&M University and community contributors.
*Official Website: http://www.rlcard.org
*Tutorial in Jupyter Notebook: https://github.com/datamllab/rlcard-tutorial
*Paper: https://arxiv.org/abs/1910.04376
*GUI: RLCard-Showdown
*Resources: Awesome-Game-AI
News:
*We have released RLCard-Showdown, GUI demo for RLCard. Please check out here!
*Jupyter Notebook tutorial available! We add some examples in R to call Python interfaces of RLCard with reticulate. See here
*Thanks for the contribution of @Clarit7 for supporting different number of players in Blackjack. We call for contributions for gradually making the games more configurable. See here for more details.
*Thanks for the contribution of @Clarit7 for the Blackjack and Limit Hold’em human interface.
*Now RLCard supports environment local seeding and multiprocessing. Thanks for the testing scripts provided by @weepingwillowben.
*Human interface of NoLimit Holdem available. The action space of NoLimit Holdem has been abstracted. Thanks for the contribution of @AdrianP-.
*New game Gin Rummy and human GUI available. Thanks for the contribution of @billh0420.
*PyTorch implementation available. Thanks for the contribution of @mjudell.Cite this work
If you find this repo useful, you may cite:Installation
Make sure that you have Python 3.5+ and pip installed. We recommend installing the latest version of rlcard with pip:
Alternatively, you can install the latest stable version with:
The default installation will only include the card environments. To use Tensorflow implementation of the example algorithms, install the supported verison of Tensorflow with:
To try PyTorch implementations, please run:
If you meet any problems when installing PyTorch with the command above, you may follow the instructions on PyTorch official website to manually install PyTorch.
We also provide conda installation method:
Conda installation only provides the card environments, you need to manually install Tensorflow or Pytorch on your demands.Examples
Please refer to examples/. A short example is as below.
We also recommend the following toy examples in Python.
R examples can be found here.Demo
Run examples/leduc_holdem_human.py to play with the pre-trained Leduc Hold’em model. Leduc Hold’em is a simplified version of Texas Hold’em. Rules can be found here.
We also provide a GUI for easy debugging. Please check here. Some demos:Available Environments
We provide a complexity estimation for the games on several aspects. InfoSet Number: the number of information sets; InfoSet Size: the average number of states in a single information set; Action Size: the size of the action space. Name: the name that should be passed to rlcard.make to create the game environment. We also provide the link to the documentation and the random example.GameInfoSet NumberInfoSet SizeAction SizeNameUsageBlackjack (wiki, baike)10^310^110^0blackjackdoc, exampleLeduc Hold’em (paper)10^210^210^0leduc-holdemdoc, exampleLimit Texas Hold’em (wiki, baike)10^1410^310^0limit-holdemdoc, exampleDou Dizhu (wiki, baike)10^53 ~ 10^8310^2310^4doudizhudoc, exampleSimple Dou Dizhu (wiki, baike)---simple-doudizhudoc, exampleMahjong (wiki, baike)10^12110^4810^2mahjongdoc, exampleNo-limit Texas Hold’em (wiki, baike)10^16210^310^4no-limit-holdemdoc, exampleUNO (wiki, baike)10^16310^1010^1unodoc, exampleGin Rummy (wiki, baike)10^52--gin-rummydoc, exampleAPI Cheat SheetHow to create an environment
You can use the the following interface to make an environment. You may optionally specify some configurations with a dictionary.
*env = rlcard.make(env_id, config={}): Make an environment. env_id is a string of a environment; config is a dictionary that specifies some environment configurations, which are as follows.
*seed: Default None. Set a environment local random seed for reproducing the results.
*env_num: Default 1. It specifies how many environments running in parallel. If the number is larger than 1, then the tasks will be assigned to multiple processes for acceleration.
*allow_step_back: Defualt False. True if allowing step_back function to traverse backward in the tree.
*allow_raw_data: Default False. True if allowing raw data in the state.
*single_agent_mode: Default False. True if using single agent mode, i.e., Gym style interface with other players as pretrained/rule models.
*active_player: Defualt 0. If single_agent_mode is True, active_player will specify operating on which player in single agent mode.
*record_action: Default False. If True, a field of action_record will be in the state to record the historical actions. This may be used for human-agent play.
*Game specific configurations: These fields start with game_. Currently, we only support game_player_num in Blackjack.
Once the environemnt is made, we can access some information of the game.
*env.action_num: The number of actions.
*env.player_num: The number of players.
*env.state_space: Ther state space of the observations.
*env.timestep: The number of timesteps stepped by the environment.What is state in RLCard
State is a Python dictionary. It will always have observation state[’obs’] and legal actions state[’legal_actions’]. If allow_raw_data is True, state will also have raw observation state[’raw_obs’] and raw legal actions state[’raw_legal_actions’].Basic interfaces
The following interfaces provide a basic usage. It is easy to use but it has assumtions on the agent. The agent must follow agent template.
*env.set_agents(agents): agents is a list of Agent object. The length of the list should be equal to the number of the players in the game.
*env.run(is_training=False): Run a complete game and return trajectories and payoffs. The function can be used after the set_agents is called. If is_training is True, it will use step function in the agent to play the game. If is_training is False, eval_step will be called instead.Advanced interfaces
For advanced usage, the following interfaces allow flexible operations on the game tree. These interfaces do not make any assumtions on the agent.
*env.reset(): Initialize a game. Return the state and the first player ID.
*env.step(action, raw_action=False): Take one step in the environment. action can be raw action or integer; raw_action should be True if the action is raw action (string).
*env.step_back(): Available only when allow_step_back is True. Take one step backward. This can be used for algorithms that operate on the game tree, such as CFR.
*env.is_over(): Return True if the current game is over. Otherewise, return False.
*env.get_player_id(): Return the Player ID of the current player.
*env.get_state(player_id): Return the state that corresponds to player_id.
*env.get_payoffs(): In the end of the game, return a list of payoffs for all the players.
*env.get_perfect_information(): (Currently only support some of the games) Obtain the perfect information at the current state.Running with multiple processes
RLCard now supports acceleration with multiple processes. Simply change env_num when making the environment to indicate how many processes would be used. Currenly we only support run() function with multiple processes. An example is DQN on blackjackLibrary Structure
The purposes of the main modules are listed as below:
*/examples: Examples of using RLCard.
*/docs: Documentation of RLCard.
*/tests: Testing scripts for RLCard.
*/rlcard/agents: Reinforcement learning algorithms and human agents.
*/rlcard/envs: Environment wrappers (state representation, action encoding etc.)
*/rlcard/games: Various game engines.
*/rlcard/models: Model zoo including pre-trained models and rule models.Evaluation
The perfomance is measured by winning rates through tournaments. Example outputs are as follows:
For your information, there is a nice online evaluation platform pokerwars that could be connected with RLCard with some modifications.More Documents
For more documentation, please refer to the Documents for general introductions. API documents are available at our website.Leduc Hold’em StrategyContributing
Contribution to this project is greatly appreciated! Please create an issue for feedbacks/bugs. If you want to contribute codes, please refer to Contributing Guide.Acknowledgements
We would like to thank JJ World Network Technology Co.,LTD for the generous support and all the contributions from the community contributors.Release historyRelease notifications | RSS feed
0.2.8
0.2.7
0.2.6
0.2.5
0.2.4
0.2.3 Leduc Hold’em Poker
0.2.1
0.2.0
0.1.17
0.1.15
0.1.14
0.1.13
0.1.12
0.1.11
0.1.10
0.1.9 Leduc Hold’em Card Game
0.1.8
0.1.7
0.1.6
0.1.5
0.1.4
0.1.3
0.1.2
0.1.1
0.1 Download files
Download the file for your platform. If you’re not sure which to choose, learn more about installing packages.Files for rlcard, version 0.2.8Filename, sizeFile typePython versionUpload dateHashesFilename, size rlcard-0.2.8.tar.gz (6.7 MB) File type Source Python version None Upload dateHashesLeduc Hold’em PokerCloseLeduc Hold’em TipsHashes for rlcard-0.2.8.tar.gz Hashes for rlcard-0.2.8.tar.gzAlgorithmHash digestSHA25648677a1bf1f5e925c3995de0890db7d111cdb11626a6f3e2e1ddbbe750c9f332MD5bad0f3be0127c61c047fb1a1f6da59b7BLAKE2-2561df79c4f68698fb70fdc4fced67d1f7d2e7250be5fdc51c9b3b6779d53806307
Register here: http://gg.gg/wyxye
https://diarynote-jp.indered.space
Expert-Level Artificial Intelligence in Heads-Up No-Limit PokerLinks
Mar 02, 2020 Leduc Hold’em is a toy poker game sometimes used in academic research (first introduced in Bayes’ Bluff: Opponent Modeling in Poker). It is played with a deck of six cards, comprising two suits of three ranks each (often the king, queen, and jack — in our implementation, the ace, king, and queen). Leduc hold ’em: The results of the various algorithms playing against the player are shown in Figure 2. Since for Leduc hold’em we can explicitly compute the best possible response against any strategy, that result is shown in the top line. Needless to say, none of the Bayesian strategies achieve this win rate. Karla Leduc Poker, 5 card draw free online, joc slots cu fructe, genting casino feng shui Win big prizes only available on Aboutslot. Check out our current giveaway.
Twitch | YouTube | Twitter
Downloads & Videos | Media Contact
Special UH-Leduc-Hold’em Poker Betting Rules: Ante is $1, raises are exactly $3. Each player can only check once and raise once; in the case a player is not allowed to check again if she did not bid any money in phase 1, she has either to fold her hand, losing her money, or raise her bet. Only player 2 can raise a raise.
DeepStack bridges the gap between AI techniques for games of perfect information—like checkers, chess and Go—with ones for imperfect information games–like poker–to reason while it plays using “intuition” honed through deep learning to reassess its strategy with each decision.
With a study completed in December 2016 and published in Science in March 2017, DeepStack became the first AI capable of beating professional poker players at heads-up no-limit Texas hold’em poker.
DeepStack computes a strategy based on the current state of the game for only the remainder of the hand, not maintaining one for the full game, which leads to lower overall exploitability.
DeepStack avoids reasoning about the full remaining game by substituting computation beyond a certain depth with a fast-approximate estimate. Automatically trained with deep learning, DeepStack’s “intuition” gives a gut feeling of the value of holding any cards in any situation.
DeepStack considers a reduced number of actions, allowing it to play at conventional human speeds. The system re-solves games in under five seconds using a simple gaming laptop with an Nvidia GPU.The first computer program to outplay human professionals at heads-up no-limit Hold’em poker
In a study completed December 2016 and involving 44,000 hands of poker, DeepStack defeated 11 professional poker players with only one outside the margin of statistical significance. Over all games played, DeepStack won 49 big blinds/100 (always folding would only lose 75 bb/100), over four standard deviations from zero, making it the first computer program to beat professional poker players in heads-up no-limit Texas hold’em poker. Casino games no download no registration.Games are serious business
Don’t let the name fool you, “games” of imperfect information provide a general mathematical model that describes how decision-makers interact. AI research has a long history of using parlour games to study these models, but attention has been focused primarily on perfect information games, like checkers, chess or go. Poker is the quintessential game of imperfect information, where you and your opponent hold information that each other doesn’t have (your cards).
Until now, competitive AI approaches in imperfect information games have typically reasoned about the entire game, producing a complete strategy prior to play. However, to make this approach feasible in heads-up no-limit Texas hold’em—a game with vastly more unique situations than there are atoms in the universe—a simplified abstraction of the game is often needed.A fundamentally different approach
DeepStack is the first theoretically sound application of heuristic search methods—which have been famously successful in games like checkers, chess, and Go—to imperfect information games.
At the heart of DeepStack is continual re-solving, a sound local strategy computation that only considers situations as they arise during play. This lets DeepStack avoid computing a complete strategy in advance, skirting the need for explicit abstraction.
During re-solving, DeepStack doesn’t need to reason about the entire remainder of the game because it substitutes computation beyond a certain depth with a fast approximate estimate, DeepStack’s ’intuition’ – a gut feeling of the value of holding any possible private cards in any possible poker situation. Jackpot cash casino instant play.
Finally, DeepStack’s intuition, much like human intuition, needs to be trained. We train it with deep learning using examples generated from random poker situations.
DeepStack is theoretically sound, produces strategies substantially more difficult to exploit than abstraction-based techniques and defeats professional poker players at heads-up no-limit poker with statistical significance.DownloadPaper & SupplementsHand HistoriesMembers (Front-back)
Michael Bowling, Dustin Morrill, Nolan Bard, Trevor Davis, Kevin Waugh, Michael Johanson, Viliam Lisý, Martin Schmid, Matej Moravčík, Neil BurchLeduc Hold’emlow-variance Evaluation
The performance of DeepStack and its opponents was evaluated using AIVAT, a provably unbiased low-variance technique based on carefully constructed control variates. Thanks to this technique, which gives an unbiased performance estimate with 85% reduction in standard deviation, we can show statistical significance in matches with as few as 3,000 games.Abstraction-based Approaches
Despite using ideas from abstraction, DeepStack is fundamentally different from abstraction-based approaches, which compute and store a strategy prior to play. While DeepStack restricts the number of actions in its lookahead trees, it has no need for explicit abstraction as each re-solve starts from the actual public state, meaning DeepStack always perfectly understands the current situation.Professional Matches
We evaluated DeepStack by playing it against a pool of professional poker players recruited by the International Federation of Poker. 44,852 games were played by 33 players from 17 countries. Eleven players completed the requested 3,000 games with DeepStack beating all but one by a statistically-significant margin. Over all games played, DeepStack outperformed players by over four standard deviations from zero.
Heuristic Search
At a conceptual level, DeepStack’s continual re-solving, “intuitive” local search and sparse lookahead trees describe heuristic search, which is responsible for many AI successes in perfect information games. Until DeepStack, no theoretically sound application of heuristic search was known in imperfect information games.’,’resolveObject’:’,’resolvedBy’:’manual’,’resolved’:true}’>’,’resolvedBy’:’manual’,’resolved’:true}’>’,’resolveObject’:’,’resolvedBy’:’manual’,’resolved’:true}’>Latest version
Released:
A Toolkit for Reinforcement Learning in Card GamesProject description
RLCard is a toolkit for Reinforcement Learning (RL) in card games. It supports multiple card environments with easy-to-use interfaces. The goal of RLCard is to bridge reinforcement learning and imperfect information games. RLCard is developed by DATA Lab at Texas A&M University and community contributors.
*Official Website: http://www.rlcard.org
*Tutorial in Jupyter Notebook: https://github.com/datamllab/rlcard-tutorial
*Paper: https://arxiv.org/abs/1910.04376
*GUI: RLCard-Showdown
*Resources: Awesome-Game-AI
News:
*We have released RLCard-Showdown, GUI demo for RLCard. Please check out here!
*Jupyter Notebook tutorial available! We add some examples in R to call Python interfaces of RLCard with reticulate. See here
*Thanks for the contribution of @Clarit7 for supporting different number of players in Blackjack. We call for contributions for gradually making the games more configurable. See here for more details.
*Thanks for the contribution of @Clarit7 for the Blackjack and Limit Hold’em human interface.
*Now RLCard supports environment local seeding and multiprocessing. Thanks for the testing scripts provided by @weepingwillowben.
*Human interface of NoLimit Holdem available. The action space of NoLimit Holdem has been abstracted. Thanks for the contribution of @AdrianP-.
*New game Gin Rummy and human GUI available. Thanks for the contribution of @billh0420.
*PyTorch implementation available. Thanks for the contribution of @mjudell.Cite this work
If you find this repo useful, you may cite:Installation
Make sure that you have Python 3.5+ and pip installed. We recommend installing the latest version of rlcard with pip:
Alternatively, you can install the latest stable version with:
The default installation will only include the card environments. To use Tensorflow implementation of the example algorithms, install the supported verison of Tensorflow with:
To try PyTorch implementations, please run:
If you meet any problems when installing PyTorch with the command above, you may follow the instructions on PyTorch official website to manually install PyTorch.
We also provide conda installation method:
Conda installation only provides the card environments, you need to manually install Tensorflow or Pytorch on your demands.Examples
Please refer to examples/. A short example is as below.
We also recommend the following toy examples in Python.
R examples can be found here.Demo
Run examples/leduc_holdem_human.py to play with the pre-trained Leduc Hold’em model. Leduc Hold’em is a simplified version of Texas Hold’em. Rules can be found here.
We also provide a GUI for easy debugging. Please check here. Some demos:Available Environments
We provide a complexity estimation for the games on several aspects. InfoSet Number: the number of information sets; InfoSet Size: the average number of states in a single information set; Action Size: the size of the action space. Name: the name that should be passed to rlcard.make to create the game environment. We also provide the link to the documentation and the random example.GameInfoSet NumberInfoSet SizeAction SizeNameUsageBlackjack (wiki, baike)10^310^110^0blackjackdoc, exampleLeduc Hold’em (paper)10^210^210^0leduc-holdemdoc, exampleLimit Texas Hold’em (wiki, baike)10^1410^310^0limit-holdemdoc, exampleDou Dizhu (wiki, baike)10^53 ~ 10^8310^2310^4doudizhudoc, exampleSimple Dou Dizhu (wiki, baike)---simple-doudizhudoc, exampleMahjong (wiki, baike)10^12110^4810^2mahjongdoc, exampleNo-limit Texas Hold’em (wiki, baike)10^16210^310^4no-limit-holdemdoc, exampleUNO (wiki, baike)10^16310^1010^1unodoc, exampleGin Rummy (wiki, baike)10^52--gin-rummydoc, exampleAPI Cheat SheetHow to create an environment
You can use the the following interface to make an environment. You may optionally specify some configurations with a dictionary.
*env = rlcard.make(env_id, config={}): Make an environment. env_id is a string of a environment; config is a dictionary that specifies some environment configurations, which are as follows.
*seed: Default None. Set a environment local random seed for reproducing the results.
*env_num: Default 1. It specifies how many environments running in parallel. If the number is larger than 1, then the tasks will be assigned to multiple processes for acceleration.
*allow_step_back: Defualt False. True if allowing step_back function to traverse backward in the tree.
*allow_raw_data: Default False. True if allowing raw data in the state.
*single_agent_mode: Default False. True if using single agent mode, i.e., Gym style interface with other players as pretrained/rule models.
*active_player: Defualt 0. If single_agent_mode is True, active_player will specify operating on which player in single agent mode.
*record_action: Default False. If True, a field of action_record will be in the state to record the historical actions. This may be used for human-agent play.
*Game specific configurations: These fields start with game_. Currently, we only support game_player_num in Blackjack.
Once the environemnt is made, we can access some information of the game.
*env.action_num: The number of actions.
*env.player_num: The number of players.
*env.state_space: Ther state space of the observations.
*env.timestep: The number of timesteps stepped by the environment.What is state in RLCard
State is a Python dictionary. It will always have observation state[’obs’] and legal actions state[’legal_actions’]. If allow_raw_data is True, state will also have raw observation state[’raw_obs’] and raw legal actions state[’raw_legal_actions’].Basic interfaces
The following interfaces provide a basic usage. It is easy to use but it has assumtions on the agent. The agent must follow agent template.
*env.set_agents(agents): agents is a list of Agent object. The length of the list should be equal to the number of the players in the game.
*env.run(is_training=False): Run a complete game and return trajectories and payoffs. The function can be used after the set_agents is called. If is_training is True, it will use step function in the agent to play the game. If is_training is False, eval_step will be called instead.Advanced interfaces
For advanced usage, the following interfaces allow flexible operations on the game tree. These interfaces do not make any assumtions on the agent.
*env.reset(): Initialize a game. Return the state and the first player ID.
*env.step(action, raw_action=False): Take one step in the environment. action can be raw action or integer; raw_action should be True if the action is raw action (string).
*env.step_back(): Available only when allow_step_back is True. Take one step backward. This can be used for algorithms that operate on the game tree, such as CFR.
*env.is_over(): Return True if the current game is over. Otherewise, return False.
*env.get_player_id(): Return the Player ID of the current player.
*env.get_state(player_id): Return the state that corresponds to player_id.
*env.get_payoffs(): In the end of the game, return a list of payoffs for all the players.
*env.get_perfect_information(): (Currently only support some of the games) Obtain the perfect information at the current state.Running with multiple processes
RLCard now supports acceleration with multiple processes. Simply change env_num when making the environment to indicate how many processes would be used. Currenly we only support run() function with multiple processes. An example is DQN on blackjackLibrary Structure
The purposes of the main modules are listed as below:
*/examples: Examples of using RLCard.
*/docs: Documentation of RLCard.
*/tests: Testing scripts for RLCard.
*/rlcard/agents: Reinforcement learning algorithms and human agents.
*/rlcard/envs: Environment wrappers (state representation, action encoding etc.)
*/rlcard/games: Various game engines.
*/rlcard/models: Model zoo including pre-trained models and rule models.Evaluation
The perfomance is measured by winning rates through tournaments. Example outputs are as follows:
For your information, there is a nice online evaluation platform pokerwars that could be connected with RLCard with some modifications.More Documents
For more documentation, please refer to the Documents for general introductions. API documents are available at our website.Leduc Hold’em StrategyContributing
Contribution to this project is greatly appreciated! Please create an issue for feedbacks/bugs. If you want to contribute codes, please refer to Contributing Guide.Acknowledgements
We would like to thank JJ World Network Technology Co.,LTD for the generous support and all the contributions from the community contributors.Release historyRelease notifications | RSS feed
0.2.8
0.2.7
0.2.6
0.2.5
0.2.4
0.2.3 Leduc Hold’em Poker
0.2.1
0.2.0
0.1.17
0.1.15
0.1.14
0.1.13
0.1.12
0.1.11
0.1.10
0.1.9 Leduc Hold’em Card Game
0.1.8
0.1.7
0.1.6
0.1.5
0.1.4
0.1.3
0.1.2
0.1.1
0.1 Download files
Download the file for your platform. If you’re not sure which to choose, learn more about installing packages.Files for rlcard, version 0.2.8Filename, sizeFile typePython versionUpload dateHashesFilename, size rlcard-0.2.8.tar.gz (6.7 MB) File type Source Python version None Upload dateHashesLeduc Hold’em PokerCloseLeduc Hold’em TipsHashes for rlcard-0.2.8.tar.gz Hashes for rlcard-0.2.8.tar.gzAlgorithmHash digestSHA25648677a1bf1f5e925c3995de0890db7d111cdb11626a6f3e2e1ddbbe750c9f332MD5bad0f3be0127c61c047fb1a1f6da59b7BLAKE2-2561df79c4f68698fb70fdc4fced67d1f7d2e7250be5fdc51c9b3b6779d53806307
Register here: http://gg.gg/wyxye
https://diarynote-jp.indered.space
コメント