예제 #1
0
def and_rank3(r1, r2):
    
    t1s = map(lambda x: x[0], r1)
    t2s = map(lambda x: x[0], r2)
    intersec = set(t1s).intersection(set(t2s))
    
    map1, map2 = {}, {}
    for t1, fr1 in r1:
        map1[t1] = fr1
    for t2, fr2 in r2:
        map2[t2] = fr2

    r1_i, r2_i = [], []
    for e in intersec:
        r1_i.append((e,map1[e]))        
        r2_i.append((e,map2[e]))
    r1_i.sort(snd_cmp)
    r2_i.sort(snd_cmp)

    sum_pos_rank = {}
    for e in intersec:
        sum_pos_rank[e] = 0.0
    for (e, pr), pos in zip(r1_i, range(1,len(r1_i)+1)):
        sum_pos_rank[e] += float(pos)
    for (e, pr), pos in zip(r2_i, range(1,len(r2_i)+1)):
        sum_pos_rank[e] += float(pos)

    final = []
    for e, val in sum_pos_rank.iteritems():
        final.append((e,val))
    final.sort(snd_cmp)
    final.reverse()
    return PageRank.normalize(final)
예제 #2
0
def or_rank(r1, r2):    
#    ret = not_rank(and_rank(not_rank(r1), not_rank(r2)))
#    ret = ret.sort(snd_cmp, None, True)
#    return ret    

    t1s = map(lambda x: x[0], r1)
    t2s = map(lambda x: x[0], r2)
    
    newr = []
    for t1, fr1 in r1:
        for t2, fr2 in r2:
            if t1 == t2:
                newr.append((t1, fr1 + fr2 - fr1 * fr2))
                
    diff12 = set(t1s).difference(set(t2s))
    diff21 = set(t2s).difference(set(t1s))
    for ent1 in diff12:
        for ent1_aux, float_rank in r1:
            if ent1 == ent1_aux:
                newr.append((ent1, float_rank))
    for ent2 in diff21:
        for ent2_aux, float_rank in r2:
            if ent2 == ent2_aux:
                newr.append((ent2, float_rank))
                    
    newr.sort(snd_cmp, None, True)
    #print str(newr)
    return PageRank.normalize(newr)
예제 #3
0
def and_rank5_gold2(tags, ranker):
    # first compute offline rank
    # OR tag formula
    tag_form = TagBooleanFormula()
    for tag in tags:
        and1 = TagBooleanConjunction()
        and1.addAtom(TagBooleanAtom(True,tag))
        tag_form.addTagAnd(and1)    
    # filter graph by OR of tags
    ranker.filter(tag_form)    
    if len(ranker.get_nodes()) > 0: 
        ranker.rank(10)           
        offline_rank = ranker.get_rank()
    else:
        offline_rank = []
    
    # AND tag formula
    and_nodes = set([])
    for tag in set(tags):
        ranker.filter_one_tag(tag)
        if tag == list(set(tags))[0]:
            and_nodes = ranker.get_nodes()
        else:
            and_nodes = and_nodes.intersection(ranker.get_nodes())
        
    # now filter by intersection
    ret = []
    for name, pagerank in offline_rank:
        if name in and_nodes:
            ret.append((name, pagerank))
    return PageRank.normalize(ret)
예제 #4
0
 def __merge_rank_and_monolitic(self, tags):
     users = self.__map_tag_users[tags[0]]
     for tag in tags[1:]:
         users = users.intersection(self.__map_tag_users[tag])
     mono_rank = []        
     for name, pagerank, pos in self.__rank:
         if name in users:
             mono_rank.append((name,pagerank))
             if self.__max_per_rank <= len(mono_rank):
                 break
     mono_rank = PageRank.normalize(mono_rank)
     return add_pos(mono_rank)
예제 #5
0
def and_rank2(r1, r2):
    
    t1s = map(lambda x: x[0], r1)
    t2s = map(lambda x: x[0], r2)
    intersec = set(t1s).intersection(set(t2s))
    map1, map2 = {}, {}
    for t1, fr1 in r1:
        map1[t1] = fr1
    for t2, fr2 in r2:
        map2[t2] = fr2

    newr = []        
    r1_int, r2_int = [], []
    for t in intersec:
        r1_int.append((t,map1[t]))
        r2_int.append((t,map2[t]))

    r1_int = PageRank.normalize(r1_int)
    r2_int = PageRank.normalize(r2_int)

    return and_rank(r1_int, r2_int)
예제 #6
0
def and_rank(r1, r2):
    
    t1s = map(lambda x: x[0], r1)
    t2s = map(lambda x: x[0], r2)
    intersec = set(t1s).intersection(set(t2s))
    map1, map2 = {}, {}
    for t1, fr1 in r1:
        map1[t1] = fr1
    for t2, fr2 in r2:
        map2[t2] = fr2

    newr = []        
    for t in intersec:
        newr.append((t,map1[t]*map2[t]))
        
#    newr = []
#    for t1, fr1 in r1:
#        for t2, fr2 in r2:
#            if t1 == t2:
#                newr.append((t1, fr1 * fr2))

    newr.sort(snd_cmp, None, True)
    #print str(newr)
    return PageRank.normalize(newr)
예제 #7
0
def not_rank(rank):
    notr = []
    for thing, float_rank in rank:
        notr.append((thing, 1-float_rank))
    notr.reverse()    
    return PageRank.normalize(notr)