def lookupTransitionProbs( final_street, final_board ) :
if final_street == 0 :
print "preflop, no transitions to return"
return False
trans_lookup = {"01" : -1, \
"12" : -1, \
"23" : -1 }
#TODO: compute TRANSITIONS_FLOP
for street in range(1,final_street+1) :
board = final_board[:street+2]
#if turn or river
if street > 1 :
cboardp = deck.collapseBoard( board )
cboard = deck.collapseBoard( board[:-1] )
cboards = "%s|%s" % (cboard,cboardp)
elif street == 1 :
cboards = deck.collapseBoard( board )
street_name = globles.int2streetname( street )
query = """select dist
from TRANSITIONS_%s
where cboards = '%s'""" % \
(street_name.upper(), cboards)
#print query
dist = conn.queryScalar( query, str )
dist = [[float(p) for p in line.split(',')] \
for line in dist.split(';')]
lookup_name = "%d%d" % (street-1, street)
trans_lookup[lookup_name] = dist
return trans_lookup
def iterateTransitions() :
#2529 insterting into flop trans
transitions = {}
conn = db.Conn("localhost")
street = 'river'
len_street = 5
#permutations v combinations is important for transitions because the
#way in which you go from 3 to 4 card board matters
for i, board_prime in enumerate( permutations( range(52), len_street ) ):
#12508.pts-1.genomequery
if i < 0 or i >= 60000000 : continue
#10866.pts-1.genomequery
#if i < 60000000 or i >= 120000000: continue
#12481.pts-3.genomequery
#if i < 120000000 or i >= 180000000: continue #finished
#12526.pts-3.genomequery
#if i < 180000000 or i >= 240000000: continue
#12635.pts-3.genomequery
#if i < 240000000 : continue
#print i
#deprecated
if street == 'flop' :
cboards = cboard_prime
else :
board = board_prime[:-1]
cboard = collapseBoard(board)
cboard_prime = collapseBoard(board_prime)
cboards = "%s|%s" % (cboard, cboard_prime)
#print board_prime
#better but untested in this context
cboard,cboardp = board2cboards( board_prime, globles.streetname2Int(street) )
cboards = canonicalizeCboards( cboard, cboardp )
##until tested
#assert False
if cboards not in transitions :
transitions[cboards] = True
q = "select count(*) from TRANSITIONS_%s where cboards = '%s'" % \
(street.upper(),cboards)
count = conn.queryScalar(q, int)
if count == 0 :
print "missing: ", cboards
computeBucketTransitions( conn, cboard, cboard_prime )
else :
print "skipping:", cboards
print len(transitions)
def computeEHS2DistsLongways_special() :
pool = Pool( processes = 8 )
count = 0
timea = time()
for board_size in range(4,5) :
start_time = time()
already_repped = {}
if board_size == 3 :
street_name = 'flops'
print_every = 10
elif board_size == 4 :
street_name = 'turns'
print_every = 100
else :
street_name = 'rivers'
print_every = 1000
count = 0
for board in combinations( range(52), board_size ) :
cboard = collapseBoard( board )
if cboard.endswith( "_p_22f" ) and cboard not in already_repped :
d_pocket_EHS2 = rollout.mapReduceComputeEHS2( pool,list(board) )
filename = "hsdists/%s/%s.hsdist" % (street_name, cboard)
fout = open( filename, 'w' )
fout.write( json.dumps( d_pocket_EHS2 ) )
fout.close()
already_repped[cboard] = makeHuman(board)
else :
pass
count += 1
if count % print_every == 0 :
print "board_size: ", board_size, " count: ", count
print "time: ", time() - timea
timea = time()
fout = open("hsdists/%s/special_representatives.txt" % street_name, 'w' )
fout.write( json.dumps( already_repped ) )
fout.close()
print "time for board_size: ", board_size, " was: ", time() - start_time
pool.close()
def computeDists(num_known_board, EV_or_HS) :
already_seen = {}
count = 0
if num_known_board == 3 : street = 'flops'
elif num_known_board == 4 : street = 'turns'
elif num_known_board == 5 : street = 'rivers'
else : assert False
for board in combinations( d.cards, num_known_board ) :
collapsed = collapseBoard( board )
if EV_or_HS == 'EV' :
path = "evdists/%s/%s.evdist" % (street,collapsed)
else :
path = "hsdists/%s/%s.hsdist" % (street,collapsed)
if collapsed in already_seen or exists(path) :
continue
else :
print count, collapsed
count += 1
board = makeHuman(board) + ['__']*(5-num_known_board)
x = []
if EV_or_HS == 'EV' :
d_pocket_EV = rollout.computeEVs( [], board, 2, num_threads=4 )
for ev in d_pocket_EV.values() :
x.append( makeRound( ev ) )
else :
d_pocket_HS = rollout.computeHSs( board, num_threads=4 )
for hs in d_pocket_HS.values() :
x.append( hs )
x.sort()
fout = open(path, 'w')
fout.write( "%s\n" % ';'.join([str(t) for t in x]) )
fout.close()
already_seen[collapsed] = True
def registerRevealedPockets(self, player_names, pockets):
# TODO: handle preflop strength via some table
for street in range(self.street):
# for street in range(len(self.past_actions)) :
self.buckets.append([0] * len(player_names))
for player_name, pocket in zip(player_names, pockets):
pix = self.players.index(player_name)
if street == 0:
street_name = "preflop"
q = """select memberships
from %s%s
where pocket = '%s'""" % (
BUCKET_TABLE_PREFIX,
street_name.upper(),
canonicalize(pocket),
)
else:
if street == 1:
board = self.board[:3]
street_name = "flop"
elif street == 2:
board = self.board[:4]
street_name = "turn"
elif street == 3:
board = self.board
street_name = "river"
cboard = collapseBoard(board)
q = """select aboard
from REPRESENTATIVES
where cboard = '%s'""" % (
cboard
)
# print q
try:
[[aboard]] = self.conn.query(q)
except Exception as ve:
self.ratio_file.write("%s\n\n" % q)
aboard = listify(aboard)
# pocket:board::apocket:aboard
# print "board",board
# print "aboard", aboard
apocket = symmetricComplement(board, pocket, aboard)
# apocket = 'AhAs'
# print "pocket",pocket
# print "apocket", apocket
q = """select memberships
from %s%s
where cboard = '%s' and pocket = '%s'""" % (
BUCKET_TABLE_PREFIX,
street_name.upper(),
cboard,
apocket,
)
# print q
try:
[[memberships]] = self.conn.query(q)
except Exception as ve:
message = "cboard: %s\naboard: %s\npocket: %s\n\n" % (cboard, aboard, pocket)
self.ratio_file.write(message)
ve.message = message
raise ve
# TODO
# eventually the beliefs should be a continuous node,
# for now let's just
# cram it into the closest to the average
memberships = [float(t) for t in memberships.split(":")]
# print "memberships: ", memberships
# print "membs", memberships
# we want the buckets to be from 1->N, not 0->N-1
w = [(i + 1) * m for i, m in enumerate(memberships)]
# print "w:", w
bucket = int(round(sum(w)))
# print "bucket,", bucket
self.buckets[street][pix] = bucket
def testSymmetric() :
conn = db.Conn("localhost")
tests = []
#cboard is 455_p_r
#representative is 4h5d5c
board = ['4d','5h','5c']
pocket = ['5d','7s']
tests.append( (board,pocket,'FLOP') )
#cboard is 9TQ_h_2fxox
#rep is 9hQhTd
board = ['9s','Qs','Tc']
pocket = ['7h','Th']
tests.append( (board,pocket,'FLOP') )
#cboard is 34QK_h_3foxxx
#rep is 3h3dQdKd
board = ['3s','3h','Qh','Kh']
pocket = ['7h','Tc']
tests.append( (board, pocket, 'TURN') )
#cboard is
#rep is 2h 4h 7d 9d Ad
board = ['2c','4h','7d','9h','Ah']
pocket = ['3c','Kh']
tests.append( (board,pocket,'RIVER') )
#cboard is 2335K_p_4f
#2h3h5hKh3d
board = ['2c','3d','3c','5c','Kc']
pocket = ['5s','Qc']
tests.append( (board,pocket,'RIVER') )
board = ['5c','5d','7c','7d','Qs']
pocket = ['6c','Qh']
tests.append( (board,pocket,'RIVER') )
for (board,pocket,street_name) in tests :
cboard = collapseBoard( board )
#print "cboard", cboard
q = """select aboard from REPRESENTATIVES where cboard = '%s'""" % \
(cboard)
[[aboard]] = conn.query(q)
#print "board", board
#print "aboard", listify(aboard)
#print "pocket", pocket
pocketp = listify( symmetricComplement( board, \
pocket,\
listify(aboard) ) )
#print "pocketp: " , pocketp
ehs2 = rollout.computeSingleEHS2( pocket, board )
print ehs2
q = """select ehs2 from EHS2_%s
where cboard = '%s' and pocket = '%s'""" % (street_name, \
cboard, \
canonicalize(pocketp) )
[[ehs2p]] = conn.query(q)
ehs2p = float(ehs2p)
print ehs2p
assert round(ehs2,4) == round(ehs2p,4)
def sampleTransitionProbs( street, n_samples, bucket_percentiles ) :
pool = Pool( processes = 4 )
dirname = "hsdists/%ss" % street
fout1 = open( "%s/transition_names.txt" % dirname, 'w' )
fout2 = open( "%s/transition_probs.txt" % dirname, 'w' )
write_buffer_1 = []
write_buffer_2 = [] # [[cboard, cboard', tran probs],[],...]
fin = open( "%s/collapsed_representatives.txt" % dirname )
representatives = load( fin.read() )
fin.close()
bkt_filenames = ["%s/%s" % (dirname, file) \
for file in listdir( dirname ) \
if file.endswith('bkts')]
dek = Deck()
for bkt_filename in sample( bkt_filenames, n_samples ) :
timea = time()
fin = open( bkt_filename)
d_pocket_buckets = load( fin.read() )
fin.close()
[rest,fileext] = bkt_filename.rsplit('/',1)
[file,ext] = fileext.rsplit('.',1)
actual_board = [str(t) for t in representatives[file]]
dek.remove( actual_board )
#enumerate the possible collapsed flops
d_cboard_aboard = {}
for next_card in dek.cards :
aboard = actual_board + makeHuman([next_card])
cboard = collapseBoard( aboard )
if cboard not in d_cboard_aboard :
d_cboard_aboard[cboard] = aboard
for cboard in d_cboard_aboard :
print bkt_filename, aboard
aboard = d_cboard_aboard[cboard]
d_pocket_EHS2 = rollout.mapReduceComputeEHS2( pool, aboard )
d_pocket_buckets_prime = computeBucket( d_pocket_EHS2, bucket_percentiles[street] )
n_buckets = len(bucket_percentiles[street])
if street == "flop" :
n_buckets_prime = len(bucket_percentiles['turn'])
elif street == 'turn' :
n_buckets_prime = len(bucket_percentiles['river'])
else : assert False
#print actual_board, aboard
tprobs = getTransitionProbs( d_pocket_buckets, \
n_buckets, \
d_pocket_buckets_prime, \
n_buckets_prime )
prob_vector = []
for b in range(n_buckets) :
for bprime in range(n_buckets_prime) :
if b in tprobs and bprime in tprobs[b] :
prob_vector.append( tprobs[b][bprime] )
else :
prob_vector.append( 0.0 )
#write_buffer_1.append( "%s\t%s" % (file,cboard) )
fout1.write( "%s\t%s\n" % (file,cboard) )
fout2.write( dump( prob_vector, width=6000 )[1:-2] + "\n" )
#write_buffer_2.append ( prob_vector )
#print bkt_filename
#print len(d_cboard_aboard)
dek.shuffle()
#fout1.write( dump( write_buffer_1 ) )
#fout2.write( dump( write_buffer_2, width=5000 )[2:] )
#write_buffer_1 = []
#write_buffer_2 = []
timeb = time()
print "board: ", bkt_filename, " took: ", timeb-timea
pool.close()
def computeEHS2Dists() :
already_repped = set([])
results = {}
count = 0
a = time()
for board in combinations( range(52), 5 ) :
count += 1
if count % 100 == 0 :
print count
print time() - a
a = time()
#pit every possible hand against 'mystery' known_pocket
#and compute the HS2 from rollout
known_pockets = ['__','__']
d_pocket_HS2 = rollout.mapReduceComputeEHS2( list(board) )
flop = ''.join( makeHuman(board[0:3]) )
cflop = collapseBoard( flop )
turn = ''.join( makeHuman(board[0:4]) )
cturn = collapseBoard( turn )
river = ''.join( makeHuman(board) )
if river == '2s2c3s4s5s' :
print d_pocket_HS2
assert False
criver =collapseBoard( river )
streets = [flop,turn,river]
cstreets = [cflop, cturn, criver]
for street, cstreet in zip(streets[:2],cstreets[:2]) :
if cstreet not in already_repped and street not in results :
results[street] = {}
for cstreet in cstreets :
already_repped.add( cstreet )
#rounding precision
precision = 4
#collect the HS2 for the river
river_hs2 = {}
for pocket in d_pocket_HS2 :
hs2 = d_pocket_HS2[pocket]
#flop and turn
for street in streets[:2] :
if street in results :
if pocket not in results[street] :
results[street][pocket] = [hs2,1]
else :
results[street][pocket][0] += hs2
results[street][pocket][1] += 1
else :
pass
#already_repped
river_hs2[pocket] =makeRound(hs2,precision)
#the 5 card board is unique, so we can print out right away
name = "hsdists/rivers/%s.hsdist" % criver
if not exists(name) :
friver = open( name, 'w' )
friver.write( json.dumps( river_hs2 ) )
#friver.write( ";".join( [str(t) for t in sorted(river_hs2)] ) + "\n" )
friver.close()
pass
if count == 500 :
#fout = open("test.txt",'w')
#fout.write( json.dumps(results) )
#fout.close()
break
pass
print "printing"
#once all the boards are done, have results[board][pocket] = HS2sum, count
for board in results :
collapsed_board = collapseBoard( board )
num_cards = len(collapsed_board.split('_')[0])
if num_cards == 3 : street_name = 'flops'
elif num_cards == 4 : street_name = 'turns'
else: assert False
#print "collapsed name:", collapsed_board, " street name: " , street_name
d_pocket_EHS2 = {}
for pocket in results[board] :
(HS2sum, count) = results[board][pocket]
ehs2 = makeRound( HS2sum / count, precision )
d_pocket_EHS2[pocket] = ehs2
filename = "hsdists/%s/%s.hsdist" % (street_name, collapsed_board)
fout = open( filename, 'w' )
#print "len HS2s: ", len(HS2s)
fout.write( json.dumps( d_pocket_EHS2 ) )
#fout.write( ';'.join( [str(t) for t in sorted(HS2s)] )+"\n" )
fout.close()
#chunked version that is not any faster, you dolt
#def iterateTransitions() :
#transitions = {}
#conn = db.Conn("localhost")
#street = 'turn'
#street_prime = 'river'
#
#chunk_size = 100
#cboards_chunk = []
#for i, board_prime in enumerate( combinations( range(52), 5 ) ):
##19148.pts-5.genomequery
##if i < 59601 or i >= 500000: continue
#
##2529.pts-4.genomequery
##if i < 535098 or i >= 1000000: continue
#if i < 600000 : continue
#
##3567.pts-4.genomequery
##if i < 1000056 or i >= 1500000: continue #finished
#if i < 2300000 : continue
#3601.pts-4.genomequery
#if i < 1507912 or i >= 2000000: continue
#3718.pts-4.genomequery
#if i < 2000007 : continue
print i
if len(cboards_chunk) == chunk_size :
cboard_where = []
cboard_prime_where = []
for cboards in cboards_chunk :
cboard, cboard_prime = cboards.split('|')
cboard_where.append("cboard = '%s'" % cboard )
cboard_prime_where.append( "cboard = '%s'" % cboard_prime )
cboard_where = ' or '.join( cboard_where )
cboard_prime_where = ' or '.join( cboard_prime_where )
#query
q_prime = """select pocket, memberships
from %s%s
where %s""" % \
(globles.BUCKET_TABLE_PREFIX, \
street_prime.upper(), \
cboard_prime_where)
q = """select pocket, memberships
from %s%s
where %s""" % \
(globles.BUCKET_TABLE_PREFIX, \
street.upper(), \
cboard_where)
print q_prime
for pocket, memb in conn.query( q_prime ) :
pass
for pocket, memb in conn.query( q ) :
pass
for cboards in cboards_chunk :
#build select dictionary
#computeBucketTransitions( conn, cboard, cboard_prime )
pass
cboards_chunk = []
a = raw_input()
board = board_prime[:-1]
cboard = collapseBoard(board)
cboard_prime = collapseBoard(board_prime)
cboards = "%s|%s" % (cboard, cboard_prime)
q = "select count(*) from TRANSITIONS where cboards = '%s'" % cboards
count = conn.queryScalar(q, int)
if count > 0 :
cboards_chunk.append( cboards )
else :
print "skipping", cboards
print len(transitions)
