Пример #1
0
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()
Пример #2
0
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()
Пример #3
0
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)