昨天在改進撲克資料的提取過程時，有了一些有趣的領悟。原本想著要把所有細節都考慮進去，結果反而讓自己陷入了一個數據過於複雜的困境。特別是在處理raise action的部分，之前總覺得每個不同的下注大小都應該被當作獨特的數據點來訓練，現在回想起來，這種過度精確的想法反而限制了模型的學習空間。
這讓我想起以前用Hand2Note分析玩家池的經驗 ，在數學以及理論上，30%跟50%的下注差異滿多的，但在實戰中，玩家的range其實並沒有太大的區別。於是我決定將各種下注大小重新分類，簡化成幾個主要類別：小注、中注、大注等。這個決定不僅讓數據更容易處理，更重要的是讓每個類別都有足夠的樣本來進行有意義的分析。
在整理數據的過程中也發現了一些之前忽略的問題。比如pot size的計算方式有誤 - 之前用的是牌局開始時的金額，而忽略已經投入底池的錢。還有玩家ID的部分，原先直接使用玩家名稱導致數據不夠一致，現在改用簡單的ID編號後，數據的一致性提高了不少。
原本打算使用Random Forest Classification來處理這project，感覺這樣可以讓整個流程變得更直接簡單。然而在檢視訓練數據時，意識到poker中previous action的重要性可能遠超過我的預期。這讓我開始思考是否需要一個能更好地處理序列數據的模型。
在與語言模型討論後，決定嘗試將特徵分成兩個分支：一個處理全局遊戲狀態，另一個專門處理動作序列。這個新方案使用了LSTM網絡來處理序列資料，雖然我還不太理解它的運作原理，但至少模型可以開始訓練了，這總是個好的起點。
回顧昨天的進展，發現有時候「簡化」反而能帶來更多可能性。就像之前用OpenHoldem時，總是想要處理所有可能的情況，結果反而讓程式變得難以維護。現在學會了如何在保持核心功能的同時，適度簡化實作方式，這或許才是真正的進步。
接下來還需要深入研究LSTM網絡的原理，雖然現在還是一頭霧水，但至少方向是對的。就像之前寫過的，有時候不需要完全理解所有細節，先讓東西能跑起來，再慢慢改進可能是更好的策略。
更新後的手牌資料提取，適用於iPoker xml hand history：
#!/usr/bin/env python3
import os
import xml.etree.ElementTree as ET
import json
import re
# ------------------------------
# Helper functions
# ------------------------------
def safe_float(text):
try:
return float(re.sub(r"[^\d\.]", "", text))
except Exception:
return 0.0
def street_from_round(round_no):
return {1: "preflop", 2: "flop", 3: "turn", 4: "river"}.get(round_no, "unknown")
def get_hole_cards(game, player):
for r in game.findall('round'):
for elem in r.findall('cards'):
if elem.attrib.get("type") == "Pocket" and elem.attrib.get("player") == player:
if elem.text:
cards = elem.text.split()
if any(c.upper().startswith("X") for c in cards):
return ["unknown", "unknown"]
else:
return cards
return ["unknown", "unknown"]
def simplify_action(action_details, round_no, blinds, pot_before_action):
"""
Simplify the action into a single string category.
Allowed original types:
- 0 → fold
- 3 → call
- 4 → check
- 5, 7, 23 → raise, which are further categorized as follows:
* Preflop (round 1), using the big blind as reference:
2.0×BB to 2.3×BB → "small raise preflop"
2.3×BB to 3.0×BB → "mid raise preflop"
3.0×BB to 4.0×BB → "big raise preflop"
≥ 4.0×BB → "all in preflop"
* Postflop (round > 1), using the pot (before the action) as reference:
< 35% of pot → "small raise postflop"
35% to 70% of pot → "mid raise postflop"
70% to 110% of pot → "big raise postflop"
≥ 110% of pot → "all in postflop"
"""
allowed_types = {0: "fold", 3: "call", 4: "check", 5: "raise", 7: "raise", 23: "raise"}
orig_type = action_details['action_type']
if orig_type not in allowed_types:
return None
base_action = allowed_types[orig_type]
new_action = action_details.copy()
if base_action != "raise":
new_action["simple_action_type"] = base_action
else:
if round_no == 1:
bb = blinds.get("big_blind", 1)
ratio = action_details['action_sum'] / bb if bb != 0 else 0
if ratio < 2.3:
new_action["simple_action_type"] = "small raise preflop"
elif 2.3 <= ratio < 3.0:
new_action["simple_action_type"] = "mid raise preflop"
elif 3.0 <= ratio < 4.0:
new_action["simple_action_type"] = "big raise preflop"
elif ratio >= 4.0:
new_action["simple_action_type"] = "all in preflop"
else:
new_action["simple_action_type"] = "raise"
else:
ratio = action_details['action_sum'] / pot_before_action if pot_before_action > 0 else 0
if ratio < 0.35:
new_action["simple_action_type"] = "small raise postflop"
elif ratio < 0.70:
new_action["simple_action_type"] = "mid raise postflop"
elif ratio < 1.10:
new_action["simple_action_type"] = "big raise postflop"
else:
new_action["simple_action_type"] = "all in postflop"
return new_action
def parse_decision_logs(root, hero):
logs = []
for game in root.findall('game'):
gamecode = game.attrib.get("gamecode", "")
general = game.find('general')
blinds = {
'small_blind': safe_float(general.findtext('smallblind', default="0")),
'big_blind': safe_float(general.findtext('bigblind', default="0")),
'ante': safe_float(general.findtext('ante', default="0"))
}
# Get players element and determine initial stacks.
players_elem = general.find('players')
# Identify small blind and big blind using round 0 actions.
small_blind_player = None
big_blind_player = None
for r in game.findall('round'):
if int(r.attrib.get('no', 0)) == 0:
for child in r:
if child.tag == "action":
if child.attrib.get('type') == "1":
small_blind_player = child.attrib.get('player')
elif child.attrib.get('type') == "2":
big_blind_player = child.attrib.get('player')
break
# Identify the button player from the dealer flag.
button_player = None
for p in players_elem.findall('player'):
if p.attrib.get('dealer','0') == '1':
button_player = p.attrib.get('name')
break
# Create mapping: small blind → 0, big blind → 1, button → 2.
player_positions = {}
if small_blind_player is not None:
player_positions[small_blind_player] = 0
if big_blind_player is not None:
player_positions[big_blind_player] = 1
if button_player is not None:
player_positions[button_player] = 2
# Get initial stacks for the mapped players.
player_stacks = {}
for p in players_elem.findall('player'):
name = p.attrib['name']
if name in player_positions:
player_stacks[name] = safe_float(p.attrib.get('chips', "0"))
active_players = {name: True for name in player_positions}
pot_size = 0.0
board_cards = []
cumulative_actions = [] # simplified actions (each includes "action_round")
snapshot_action_counter = 0
# Track cumulative contributions from each player.
player_contributions = {name: 0.0 for name in player_positions}
for r in game.findall('round'):
round_no = int(r.attrib.get('no', 0))
for child in r:
if child.tag == "cards":
if child.attrib.get("type") != "Pocket":
if child.text:
board_cards.extend(child.text.split())
elif child.tag == "action":
action_details = {
'player': child.attrib.get('player'),
'action_type': int(child.attrib.get('type')),
'action_sum': safe_float(child.attrib.get('sum')),
'action_round': round_no
}
player = action_details['player']
contribution = action_details['action_sum']
# For round 0 (blinds/antes): update contributions and pot; no snapshot.
if round_no < 1:
if player in player_contributions:
player_contributions[player] += contribution
pot_size += contribution
continue
# For rounds ≥ 1, capture current pot (before adding current action).
current_pot = pot_size
# Actor's current stack (as seen when taking the action).
actor_current_stack = player_stacks.get(player, 0.0) - player_contributions.get(player, 0.0)
# Simplify the action.
simple_action = simplify_action(action_details, round_no, blinds, current_pot)
if simple_action is not None:
snapshot_action_counter += 1
simple_action['action_no'] = snapshot_action_counter
# Replace the "player" field with its numeric value.
numeric_player = player_positions.get(player)
simple_action["player"] = numeric_player
# Build current stacks keyed by numeric positions.
current_player_stacks = { player_positions[name] : (player_stacks[name] - player_contributions.get(name, 0.0))
for name in player_positions }
# Create snapshot only for non-hero actions.
if player != hero:
snapshot = {
"gamecode": gamecode,
"round_no": round_no,
"current_street": street_from_round(round_no),
"blinds": blinds,
"player_positions": player_positions, # mapping from name to number
"player_stacks": current_player_stacks, # mapping from number to current stack
"pot_size": current_pot,
"board_cards": board_cards.copy(),
"previous_actions": [],
"action": simple_action.copy(),
"players_remaining": sum(1 for v in active_players.values() if v),
"is_button": (player_positions.get(player) == 2),
"actor_hole_cards": get_hole_cards(game, player),
"actor_stack_size": actor_current_stack,
"actor_position": player_positions.get(player)
}
# For previous actions, use the numeric "player" already set.
for act in cumulative_actions:
act2 = act.copy()
# Since act["player"] is now numeric, we simply assign it.
act2["player_position"] = act["player"]
snapshot["previous_actions"].append(act2)
logs.append(snapshot)
# Update contributions and pot AFTER snapshot creation.
if player in player_contributions:
player_contributions[player] += contribution
pot_size += contribution
if simple_action is not None:
cumulative_actions.append(simple_action)
# Mark a player as inactive if they folded.
if action_details.get('action_type') == 0:
active_players[player] = False
return logs
# ------------------------------
# Process All XML Files in ipoker_hh Folder
# ------------------------------
def process_all_hand_history(root_folder, hero=None):
all_logs = []
for dirpath, dirnames, filenames in os.walk(root_folder):
for filename in filenames:
if filename.endswith(".xml"):
file_path = os.path.join(dirpath, filename)
try:
tree = ET.parse(file_path)
root_xml = tree.getroot()
if hero is None:
session_general = root_xml.find('general')
if session_general is not None and session_general.find('nickname') is not None:
hero = session_general.find('nickname').text.strip()
logs = parse_decision_logs(root_xml, hero)
all_logs.extend(logs)
print(f"Processed file: {file_path} -> {len(logs)} snapshots.")
except ET.ParseError as e:
print(f"Error parsing XML file: {file_path}", e)
return all_logs
# ------------------------------
# Main
# ------------------------------
if __name__ == '__main__':
root_folder = "ipoker_hh_test" # Adjust folder path as needed.
hero_name = None # Or manually set your hero's name.
print("Processing all hand history XML files in folder:", root_folder)
all_logs = process_all_hand_history(root_folder, hero=hero_name)
print("Total snapshots extracted:", len(all_logs))
with open("logs.json", "w") as outfile:
json.dump(all_logs, outfile, indent=4)
print("Data extraction complete. Saved to logs.json")