Example #1
0
 def game_end(self):
     board.draw()
     winner = cmp(player1.score(), player2.score())
     if not winner:
         print(nl, self.tiemsg)
     else:
         print(nl, self.winmsg % (player1 if winner>0 else player2))
     sys.exit()
Example #2
0
 def game_end(self):
     board.draw()
     winner = cmp(player1.score(), player2.score())
     if not winner:
         print(nl, self.tiemsg)
     else:
         print(nl, self.winmsg % (player1 if winner > 0 else player2))
     sys.exit()
Example #3
0
def get_data(corpus):
    '''为验证集验证模型使用的数据
    X : numpy.array, (num_sample,num_feature)
    Y : numpy.array, (num_sample,1)
    samples : python-list,(num_sample,)
    ans : python-list, (num_question,num_answer)
    question2sample : python-dict, key:questionindex , value:sampleindexs
    '''
    X, Y, samples, ans = [], [], [], []
    gold_tuples, question2sample = [], {}

    sample_index, true_num, hop2_num, hop2_true_num = 0, 0, 0, 0
    for i in range(len(corpus)):
        candidate_tuples = corpus[i]['candidate_tuples']
        gold_entities = corpus[i]['gold_entities']
        gold_relations = corpus[i]['gold_relations']
        gold_tuple = tuple(gold_entities + gold_relations)
        answer = corpus[i]['answer']
        q_sample_indexs = []
        for t in candidate_tuples:
            features = candidate_tuples[t]
            if len(gold_tuple) == len(set(gold_tuple).intersection(set(t))):
                X.append([features[-1]])
                Y.append([1])
            else:
                X.append([features[-1]])
                Y.append([0])
            samples.append(t)
            q_sample_indexs.append(sample_index)
            sample_index += 1
        ans.append(answer)
        gold_tuples.append(gold_tuple)
        question2sample[i] = q_sample_indexs

        if_true = 0
        #判断gold tuple是否包含在候选tuples中
        for thistuple in candidate_tuples:
            if cmp(thistuple, gold_tuple) == 0:
                if_true = 1
                break
        #判断单实体问题中,可召回的比例
        if if_true == 1:
            true_num += 1
            if len(gold_tuple) <= 3 and len(gold_entities) == 1:
                hop2_true_num += 1
        if len(gold_tuple) <= 3 and len(gold_entities) == 1:
            hop2_num += 1

    X = np.array(X, dtype='float32')
    Y = np.array(Y, dtype='float32')
    print('单实体问题中,候选答案可召回的的比例为:%.3f' % (hop2_true_num / hop2_num))
    print('候选答案能覆盖标准查询路径的比例为:%.3f' % (true_num / len(corpus)))
    return X, Y, samples, ans, gold_tuples, question2sample
Example #4
0
def compute_precision(gold_tuples, predict_tuples, predict_props):
    '''
    计算单实体问题中,筛选后候选答案的召回率,float
    '''
    true_num = 0
    one_subject_num = 0
    for i in range(len(gold_tuples)):
        gold_tuple = gold_tuples[i]
        if len(gold_tuple) <= 3:
            one_subject_num += 1
        for j in range(len(predict_tuples[i])):
            predict_tuple = predict_tuples[i][j]
            if cmp(predict_tuple, gold_tuple) == 0:
                true_num += 1
                break
    return true_num / one_subject_num
Example #5
0
def get_extensible_model(modulname, required_attributes):
    """Returns a Gtk.ListStore of found classes that implement a specific function.
    
    These classes are searched in the builtin module 'modulname', and then
    in all .py or .pyc files in the directory config.user_data_dir/modulname.

    The attribute short_description is implicitely required.

    The sort order is set to the priority field."""
    # builtin
    model = _get_extensible_model_from_modulname(modulname, required_attributes)

    # user specific
    folder = get_user_extension_folder(modulname)
    if not os.path.isdir(folder):
        try:
            os.makedirs(folder)
        except OSError:
            _logger.debug("Could not create '%s'" % folder)
        else:
            _logger.debug("Created '%s'" % folder)

    try:
        files = os.listdir(folder)
    except OSError:
        _logger.warning("Could not list '%s'" % folder)
    else:
        modules = set()
        for file in files:
            if file.endswith(".py"):
                modules.add(file[0:-3])
            elif file.endswith(".pyc"):
                modules.add(file[0:-4])

        sys.path.insert(0, folder)
        for found_module in modules:
            _get_extensible_model_from_modulname(found_module, required_attributes, model)
        del sys.path[0]
    
    model.set_default_sort_func(lambda model, iter1, iter2, user_data : utils.cmp(model.get_value(iter1, constants.EXTENSIBLE_MODEL_COLUMN_PRIORITY),
                                                                 model.get_value(iter2, constants.EXTENSIBLE_MODEL_COLUMN_PRIORITY)), None)
    model.set_sort_column_id(constants.GBR_GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, Gtk.SortType.ASCENDING)
    return model
Example #6
0
def test_that_check_the_ability_to_play_alone(_, __, rf, tester):
    import tmp_name.business.actions
    import tmp_name.views.gwbmods

    request = rf.post('/create_game/', data=dict(type=1))
    request.user = tester
    response = create_game(request)
    assert response.status_code == 201
    key = loads(response.content)['result']

    request = rf.post('/init_game/')
    request.user = tester
    response = init_game(request)
    assert response.status_code == 200
    assert key == 7777

    gg = GiG.objects.get(gamer=tester)
    game = gg.game

    assert gg.chief
    assert gg.color == 16515072
    assert gg.gamer.id == tester.id
    assert gg.latitude == -1  # изменяется при update_state
    assert gg.longitude == -1  # -||-
    assert gg.status == GiG.StatusGiGChoices.ACTIVE
    dump = gg.__dict__

    assert game.cnt_gamers == 1
    assert game.duration is None
    assert game.status == game.StatusGameChoices.INITIALIZED
    assert game.type_game == 1

    request = rf.post('/begin_game/', data=dict(duration=155))
    request.user = tester
    response = begin_game(request)
    gg = GiG.objects.get(gamer=tester)
    game = gg.game

    assert cmp(gg.__dict__, dump, exclude=['_state'])
    assert game.StatusGameChoices.STARTED == game.status
    assert game.time_end_game == 165
    assert game.duration == 155
Example #7
0
def get_train_data(corpus):
    '''
    为训练集的候选答案生成逻辑回归训练数据,由于正负例非常不均衡,对于负例进行0.05的采样
    '''
    X, Y = [], []
    true_num, hop2_num, hop2_true_num = 0, 0, 0

    for i in range(len(corpus)):
        candidate_tuples = corpus[i]['candidate_tuples']  #字典
        gold_entities = corpus[i]['gold_entities']
        gold_relations = corpus[i]['gold_relations']
        gold_tuples = tuple(gold_entities + gold_relations)
        for t in candidate_tuples:
            features = candidate_tuples[t]
            if len(gold_tuples) == len(set(gold_tuples).intersection(set(t))):
                X.append([features[-1]])  # mention长度??????????
                Y.append([1])
            else:
                prop = random.random()
                if prop < 0.05:
                    X.append([features[-1]])
                    Y.append([0])

        if_true = 0  # 判断答案是否召回
        for thistuple in candidate_tuples:
            if cmp(thistuple, gold_tuples) == 0:
                if_true = 1
                break
        if if_true == 1:
            true_num += 1
            if len(gold_tuples) <= 3 and len(gold_entities) == 1:
                hop2_true_num += 1
        if len(gold_tuples) <= 3 and len(gold_entities) == 1:
            hop2_num += 1

    X = np.array(X, dtype='float32')
    Y = np.array(Y, dtype='float32')
    print('单实体问题中,候选答案可召回的的比例为:%.3f' % (hop2_true_num / hop2_num))
    print('候选答案能覆盖标准查询路径的比例为:%.3f' % (true_num / len(corpus)))
    return X, Y
Example #8
0
 def sort(self, model, iter1, iter2, user_data):
     if self._case_sensitive:
         return utils.cmp(model.get_value(iter1, 0), model.get_value(iter2, 0))
     else:
         return utils.cmp(model.get_value(iter1, 0).lower(), model.get_value(iter2, 0).lower())
Example #9
0
    return Vl

def savelist(f,l):
    for x in l:
        f.write("%.20f\n"%x)

def save(r,U3,Vloc,V0,V1,V2):
    f=file("potentials.dat","w")
    savelist(f,r)
    savelist(f,U3)
    savelist(f,Vloc)
    savelist(f,V0)
    savelist(f,V1)
    savelist(f,V2)

r=parse_fort67()
rho=parse_1adns()
U3,UP0,UP1,UP2=parse_fort49()
va,val,ngau=parse_1adat()
Vloc=computeVloc(r,va)
V0,V1,V2=[computeVl(L,r,val,ngau) for L in (0,1,2)]
utils.cmp(UP0,[x+y for (x,y) in zip(Vloc,V0)],7)
utils.cmp(UP1,[x+y for (x,y) in zip(Vloc,V1)],7)
utils.cmp(UP2,[x+y for (x,y) in zip(Vloc,V2)],7)

save(r,U3,Vloc,V0,V1,V2)

#plot(r,rho,U3,UP0,UP1,UP2,Vloc)
U=[x+y for (x,y) in zip(Vloc,U3)]
plot2(r,rho,U,V0,V1,V2)
Example #10
0
def optimize_metadata(filelist, metadata):
    unique_files = []
    for files in filelist:
        # files - кортэж (file_in_backup, new_file, status) новый файл который нужно будет добавить
        # Если filse это строка, зачит файл действительно уникальный и его нужно будет добавить в архив
        if (isinstance(files, str)):
            continue

        backupfile, newfile, status = files

        if (status == 'renamed') or (status == 'removed_and_renamed'):
            # Получение старых метаданных файла с бэкапа
            file_metadata = metadata[backupfile]
            # Если обновляемый файл имеет дочернее файлы, которые ссылаються на него, изменяет у них имя родителя
            # Нужно при распаковке файла с архива
            if file_metadata['has_child']:
                # Изменение имени родителя в дочерних файлах
                for child in file_metadata['childs']:
                    metadata[child].update({
                        'has_parent': True,
                        'parent': backupfile
                    })
            # Привязка нового имени файла к старым метаданным
            metadata[newfile] = file_metadata
            metadata[backupfile]['is_deleted'] = True
            # del metadata[backupfile]

        elif (status == 'removed'):
            # Привязка нового имени файла к старым метаданным
            metadata[newfile] = metadata[backupfile]
            # Удаляет старые данные
            # del metadata[backupfile]
            metadata[backupfile]['is_deleted'] = True

        elif (status == 'copied'):
            # Получение метаданных файла с бэкапа
            file_metadata = metadata[backupfile]
            new_file_metadata = get_information(newfile)

            if (metadata[backupfile]['has_child']):
                childs_list = metadata[backupfile]['childs']
                childs_list.append(newfile)
                metadata[backupfile].update({'childs': childs_list})
            else:
                metadata[backupfile].update({
                    'has_child': True,
                    'childs': [newfile]
                })

            new_file_metadata.update({
                'has_parent': True,
                'parent': backupfile
            })
            metadata[newfile] = new_file_metadata

        elif (status == 'updated'):
            # backupfile - файл который нужно будет обновить
            for key in metadata:
                # key - файл находящийся в архиве и является копией backupfile
                filedata = metadata[key]
                # Если в архие есть копия обновляймого файла, изменяет метаданные
                if (utils.cmp(backupfile, filedata)):
                    # Если обновляемый файл имеет копию, передает уникальное имя (ufn) этого файла дочернему (это имя используется при распаковке)
                    # и стирает данные о родстве этих файлов
                    if (filedata['has_child']):
                        metadata[key].update({
                            'has_parent': False,
                            'parent': None
                        })
                        metadata[backupfile].update({
                            'has_child': False,
                            'childs': []
                        })

                    if (filedata['has_parent']):
                        # Стираем данные о родителе в дочернего файла, поскольку он будет обновлен и не схож со своим радителем
                        metadata[key].update({
                            'has_parent': False,
                            'parent': None
                        })
                        # Стираем данные о дочернем файле в родителя
                        metadata[backupfile].update({
                            'has_child': False,
                            'childs': []
                        })

        elif (status == 'deleted'):
            file_metadata = metadata[backupfile]
            if (file_metadata['has_child']):
                for child_name in file_metadata['childs']:
                    child_metadata = metadata[child_name]
                    # Передача уникального имени файла в архиве, дорернему файлу и удаление родственности
                    child_metadata.update({
                        'has_parent': False,
                        'parent': None,
                        'ufn': file_metadata['ufn']
                    })
            # Делает отметку, что файл был уделен с архива
            file_metadata.update({'is_deleted': True})

        else:
            unique_files.append(newfile)
    return unique_files