I'm looking for information about how to represent the game state (model inputs) in NLHE for machine learning. Do you know of any resources that I might find helpful?

I've been teaching myself machine learning, and what better application could there be than my own NLHE hand history database! I've made some rudimentary machine learning models, like predicting my own preflop hand range based on my actions, or predicting whether a player will call or fold based on the actions on that street. But even for these simple models, I'm having trouble coming up with a representation of the game state that is both compact and informative, especially postflop, that can serve as input to my models.

For example, I've considered inputs like the required equity to call, the number of active players remaining in the hand, the relative position of the player, and some downright fugly representations of what's on the board like the highest board card, the greatest number of cards of a single suit, and how many straights are possible.

Rather than continuing to try to reinvent the wheel here, do you know where I can find resources like how one of the already-existing machine learning/AI models (e.g., PokerSnowie, AlphaHoldem, DeepStack, etc) represents the game state? Academic papers are fine even if paywalled -- I have university library access to most academic databases -- as long as they actually specify the inputs that go into the models.

Thanks!

You might check out the GTOWizard blogs. I'm not sure if there's anything technical enough to be of use to you, as most of the articles are consumer-focused, but here's an article that goes over the basics:

http://blog.gtowizard.com/gto-wizard-ai-explained/

Maybe Tombos will chime in. He's very knowledgeable about this sort of stuff.

Thanks, GreatWhiteFish!

Grendel, the GScholar keyword you're looking for is "Deep CFR". It's like regular CFR on the current street, but instead of solving future streets, you abstract the values using a neural network.

DeepCFR
DREAM
DeepSolver

There are plenty of implementations; It's an evolving field, and I might be wrong about some of the details here. But as I understand it, you encode the ranges and board state into an input, then try to predict the regrets or EV of your hands as an output.

Great stuff, thank you so much!

It looks like I was barking up the wrong tree in terms of abstracting the game state myself (e.g., calculating the required equity or the number of possible straights on the board). I assumed that just feeding the model raw board cards wouldn't be enough, but from what I can tell after quickly skimming the papers that Tombos linked to, that's basically what I should be doing.