Well, getAmbigFrac gets the average frequency of all hands that match a pattern like XYs or XYo. However, on the river, suits matter -- they can have a large effect on the EVs. So, just because BB is sometimes checking and sometimes betting with some T6o hands doesn't mean he's playing a mixed strategy with any combo in particular.

I think that's enough to account for your confusion, but also, a few hundredths of a BB isn't a huge difference in EVs. Once you find a particular hand combo you think is indiff at equilibrium, try monitoring the difference in EVs each iteration and see how fast it converges. Additionally, playing any mixed strategy at equilibrium implies an indifference -- there's nothing special about a 50/50 mix like you refer to.

I believe the algorithm should converge as long as the sequence of mixing factors we use converges to 0 but its partial sums diverge.

Yea, the full game is big. Here's a couple ideas I wrote a while back on the approximating postflop game.

http://forumserver.twoplustwo.com/15...-game-1408420/

Another idea would be to replace whole postflop subtrees with simpler models. Of course, there are also faster algorithms out there as well. I don't quite see how to use MC with FP.

Is that ten thousand? Those are the effective stacks behind at the beginning of the hand or at the beginning of the river? What's the river pot size? But yea, seems like a very limited number of actions.

How are you calculating the EV? You're right that the players' EVs in any spot should sum to the total amount of chips in play, but if you're using the getAvgEVs function we wrote, some card removal effects make it not quite right when used at any decision points except for the beginning of the hand. I talked about this in the video. You can correct for those effects with a bit more work, though.

Check on your EV calcs -- sounds like that could be the problem, and it's a complicated part of the code.

Fix one player's strategy and calculate the other guy's max expl EV vs it. Then pick one hand combo to focus on, check it's EV at each decision point, and verify those EVs with manual calculation.

For more debugging/diagnosing ideas, see post #16 in this thread.

Yea, you can do anything in iPython that you can do in python, and it's a general purpose programming language. Getting the basic functionality that you describe sounds like something that'd be pretty straightforward to get working in an afternoon for someone with some experience, but if you're just learning the language, it's hard to give a time estimate.

It's not something I've done before, but I guess you just want to take every hand in your range and look at every flop, keep track of how many times you make each type of hand, and take the appropriate weighted averages to get frequencies. The most tedious (and potentially slow) part of this seems like it'll be figuring out exactly what hand you have (pair, twopair, straight, etc) on each board. However, I believe the poker-eval library can do this for you, so I'd check its documentation before trying to roll my own.

Glad you ask -- I recently looked into it. It turned out to be sort of painful, so I'll document it here in case it helps someone else. I've never really used a Mac much, so no promises that this is the most efficient route.

FWIW, my Mac is running OSX 10.9.3. It came with python installed, and I guess all Macs do? Open a command prompt (i.e a Terminal window) and verify that if you run "python2.7", you get a python prompt.

I ended up not using the Anaconda distribution. Tried it at first, and it was more trouble than it was worth.

So anyway --

1. Install pokereval

- Go here: http://download.gna.org/pokersource/sources/ and download poker-eval-138.0.tar.gz.
- Open a terminal, find the file you downloaded, unzip it with "tar xzvf poker-eval-138.0.tar.gz" and change into the poker-eval-138.0 directory.
- Run: ./configure
- Run: make
- Run: sudo make install

2. Install pkg-config

- Go here: http://pkgconfig.freedesktop.org/releases/ and download pkg-config-0.28.tar.gz.
- Find the file you downloaded in the terminal, decompress it with tar zxvf, and change into the directory.
- Run: ./configure --with-internal-glib
- Run: make
- Run: sudo make install

3. Install Homebrew

- Go here: http://brew.sh/
- Run the command at the bottom of the webpage to install Homebrew

4. Install automake

- Run: brew install automake

5. Install pypoker-eval

- Go here: http://download.gna.org/pokersource/sources/ and download pypoker-eval-138.0.tar.gz.
- Decompress it with "tar xzvf", change into the new directory.
- Run: export CFLAGS="-I/usr/local/include/poker-eval"
- Edit the files Makefile.am, config/ccpython.m4, and config/python.m4, and search and replace all instances of "2.6" and "2_6" with "2.7" and "2_7", respectively.
- Run: autoreconf (if it complains about missing files, run automake --add-missing and then run autoreconf again)
- Edit config/py-compile and delete line 52. (The line says "exit 1" and is right below something about "Missing argument to --destdir" (destdir, not basedir).)
- Run: ./configure
- Run: make
- Run: sudo make install
- Change directories: cd /usr/local/lib/python2.7/site-packages/ and run: sudo mv *pokereval* /Library/Python/2.7/site-packages/

7. Install pip

- Run: curl -o get-pip.py https://bootstrap.pypa.io/get-pip.py
- Run: sudo python2.7 get-pip.py

8. Install iPython and friends

- Run: sudo pip install pyzmq
- Run: sudo pip install jinja2
- Run: sudo pip install tornado
- Run: sudo pip install ipython

Verify that you can open an ipython notebook by running "ipython2 notebook", run "import pokereval" with no errors, and follow along with the intro vids!

Unfortunately this is beyond my level of understanding the code (I've tried). If anyone could help get me started on doing this is would be greatly appreciated.

thanks Will

As a beginner at programming, I'd also be grateful for some help on this.

In particular, what is the best way to adapt our code so that we can fix one player's strategy and calculate the the other guy's max expl EV vs it.

Thanks

Getting towards the end of the video series, and running into an issue. Have debugged for a long time and can't quite find the problem.

I have successfully programmed through running the Fictitious Play simulation of the large game tree (soln2) of the Details and Example video and am not receiving any errors, but I am receiving slightly, yet clearly wrong results. I also received wrong results in the minrshoveTree equilibrium solution.

Up to running the minrShoveTree equilibrium all of my results have been exactly correct. One interesting occurrence is that the first SB average EV in both simulations is exactly correct, 20.87777 for the minrShoveTree and 18.34159 for the T tree, but then they diverge after that. The 100th iteration of the minrShoveTree gives me an SB average EV of 20.2619 and BB average EV of 20.2733 which add clearly above 40 like they should, and likewise for the T tree.

Any clue what could be causing this, I have gone back over the code more times than I would like to admit. Thanks

Well, I feel like composing ranges into strategies and then finding max expl counter strategies was like half of the video series , so you might want to re-watch some sections if you want details. That said, assuming everything is coded up right, the cliffnotes version looks something like:

1. make a strategy pair (remember this is basically a set of ranges -- one for each player for every spot in the game)

Remember by default, we set it up so that the players would start at the top of the tree with the starting ranges given and then split their ranges by essentially playing each hand randomly/uniformly at each decision point. But if you want to change a range, you can essentially do something like:

Here, index is an integer which is the number of the range you want to change. (The numbers for each action are printed on the decision tree.) Of course, if you change one range, you'll have to change others too -- you have to play all the hands you arrive at any decision point with some way, and you can't play any you don't get there with.

2. call setMaxExplEVs

If you wanna find SB's max expl EVs vs BB's strat:

If BB is hero, switch SB and BB.

3. look at the EVs

E.g., if you want to see the SB's EV with Qh9s (numerical representation: [10,46]) at decision point 3, then

First of all, check out the errata. It seems from your numbers that you might be affected by the last one in particular. And keep in mind that if you were affected by that bug when you generated your equity arrays, you need to delete and re-generate them after fixing it. But none of them should cause the behavior you describe.

I suggest that you check your EV calcs as I describe in the previous post. However, if you get the first SB avg EV right, it indicates that a later step is more likely at fault: finding the max expl strategy from the max expl EVs or the mixing of ranges. So, look at each of those steps individually, too. Following from the code above, get the SB's max expl strat with:
and then look at the ranges and verify they're correct. If no luck, call updateRanges manually and check the mixing:

Thanks Will,

I believe I found the error,

In the first getMaxEVStratHelper I had currRange instead of result[iChild]. I had to go over that at least 5 times and didn't catch it.

I feel like I'm getting close to completely understanding the video series, as it's my first major foray in computer programming, and looking forward to seeing everything that can be done with it. Thanks for the quality video series and the help in this thread.

Yes, I´m using the getAvgEV. To be honest watched lots of parts of the videos at 2x speed as I also studied computer science and had experience with python so most of the videos were to slow for me (perfect for newbies as its supposed to be, I must say). Probably have missed the card ramoval effects in that function. Will review the video and fix the function.

If I have success, I should get a close to zero result in that scenario right?

Thanks again

http://forumserver.twoplustwo.com/15...-game-1408420/

Thnx Will, very interesting post.
Did you use this for volume II or complete flop simulation?

Hi,
thanks for taking the time to answer questions till now. I appreciate that.

Till now, I reduced required harddisk resources, I reduced required RAM resources and I reduced execution time.
And such, I would be interested into a simple benchmark; ie you running 300 iterations solving the turn tree with the code in the vid pack and then again with your optimized code.
I would be interested into %reduction of execution time so I have a bit of idea to which extent making the code faster is certainly doable as you have already done it.

Hey Will,

I'd like to know if you feel the generation of flops in the linked thread below is solid for what you wanted out of it? I have been struggling with finding ways to drastically limit the amount of flops i need to work through, and the thread you created below seems really interesting to me, and i'm surprised at the lack of action it generated.

Hey Will, first of all I wanne say the book and the videos are great.

After completing the videoseries, I'm now trying to write my own c++ program as well. What I don't quite understand. Can I use pokereval with c++ on windows? What do I need for it? All I found was this
https://github.com/v2k/poker-eval
and I really don't understand what to do with all those files.
What are you using in your c++ program, if you don't mind me asking?

Oh and while I'm already asking. Is there anything faster than to work with simple arrays or vectors? Are they alike speedwise to the numpy-arrays?

Thanks.

So I'm now getting ranges that identical to the ones posted by other for the large tree. However, my average ev's are wrong both for the minrShoveTree and the large tree. For the minrShoveTree, my initial average ev's are different to yours, and tend to deviate further away from equilibrium. i.e both numbers get slightly smaller with more trials.

First of all: posting as someone else then post above, don't have a 2+2 account. But thanks for your fforts in this thread

My Question:

i'm currently watching video 7 and near the end of it i get the following error i don't quite understand. Any1 able to identify my mistake?

Yes you miss parenthesis after the second getFilename... () which is a function.
The way to find the error is likewise : python tells you there is an error in this function. But this same function is called without error the line just before which is usually impossible if the arguments passed have not evolved, hence a problem with the arguments, which are in fact not passed at all.
For the second error, as you describe the hand with strings, I guess you want to use the function string2card.

Working through the 5 questions at the end of the Details and Example video, and it's probably somewhere, although I am unable to find it. What's the best method to find the EV at each index. soln2.evs[player][index] gives me an array, but I'm having a difficult time deciphering it.

Also, is there a way to list each hand, with the corresponding EV at each specific decision tree?

I remember it is explained in the video, from memory it is:

soln2.evs[player][index][hand]
or for a specific hand:
soln2.evs[player][index][pe.string2card('Ac')][pe.string2card('2s')], be careful to respect the order of colors.

That's correct for a single hand which was clearly done in the videos, but I was looking for the EV for the entire range for each player at a specific Index. Say after the backdoor flush comes/or doesn't come in you would need to see the each players complete EV to compare who it benefits the most.

For example when I type in soln2.evs['BB'][21] I get this output, and it doesn't make very much sense:

array([[ 0. , -6.50162106, 13.07313899, ..., -1. ,
20.96047938, 23.90847809],
[ 0. , 0. , -5.51470433, ..., -1. ,
-4.88815789, -5.43427551],
[ 0. , 0. , 0. , ..., -1. ,
13.86718474, 13.65036881],
...,
[ 0. , 0. , 0. , ..., 0. ,
-1. , -1. ],
[ 0. , 0. , 0. , ..., 0. ,
0. , 24.397463 ],
[ 0. , 0. , 0. , ..., 0. ,
0. , 0. ]])

And for listing out each hand and their specific EV's at a certain Index i'm thinking I will have to write my own function for that.

I'd be keen to know how to list hands like this, too.

Also, is there an easy way to output a list of how many combos of each hand there are in a range? It can be hard to tell this just from the hand range graphs alone.

This is why we wrote the function:
# Inputs: strats, a StrategyPair
# player
# index: the number of an action (index is 0 at top of tree)
# Output: average ev over all hands, of player at index using strats
getAvgEVs(soln2,'BB',21)