Python Tagger.classify方法代码示例

# 需要导入模块: from tagger import Tagger [as 别名]
# 或者: from tagger.Tagger import classify [as 别名]
class SearchEngine:
    """
    classe que considero a principal desse modulo. É a estrutura de dados que
    contém os arquivos para o processamento da engine.
    """

    def __init__(self):
        self.tagger = Tagger('portugues')

    def insert(self, files):
        """
        Esse método tem como entrada um array de arquivos, retornando uma lista de indexação reversa.
        """
        dataset = []
        for f in files:
            paragraph = sent_tokenize(f[1].lower())
            for index, p in enumerate(paragraph):
                words = word_tokenize(p)
                classes = self.tagger.classify(words)
                for c in classes:
                    if re.match('N', c[1]):
                        keysId = [item['_id'] for item in dataset]
                        print 'qtd chaves: ' + str(len(keysId))
                        if c[0] in keysId:
                            ind = keysId.index(c[0])
                            files = dataset[ind]
                            if os.path.basename(f[0]) in files.keys():
                                if not index in dataset[ind][os.path.basename(f[0])]:
                                    dataset[ind][os.path.basename(f[0])].append(index)
                            else:
                                dataset[ind][os.path.basename(f[0])] = [index]
                        else:
                            dataset.append({'_id':c[0], os.path.basename(f[0]):[index]})
        return dataset

    def extract(self, data):
        """
        Algoritmo de busca simples que retorna um tupla com os arquivos.
        """
        print 'vim pelo método extract'
        for d in data:
            paragraphs = []
            try:
                d.pop('_id')
            except KeyError:
                'ok'
            for k in d.keys(): # o [1:] para eliminar a primeira chave!
                #path_name = os.path.abspath('backend')
                path_name = os.path.abspath('backend') + '/texts/'
                #text = open(path_name+'\\texts\\'+ k + '.txt').read().decode('utf-8')
               # print path_name+'\\'+ k + '.txt'
                text = open(path_name+ k + '.txt').read().decode('utf-8')
                text_sent = sent_tokenize(text)
                for index in d[k]:
                    paragraphs.append(text_sent[index])
        print paragraphs
        return set(paragraphs)

# 需要导入模块: from tagger import Tagger [as 别名]
# 或者: from tagger.Tagger import classify [as 别名]
 def genKeyWords(self, question):
   questionToken = self.preProcess(question)
   tagger = Tagger('portugues')
   token = tagger.classify(questionToken)
   keyList = []
   for tok in token:
     if tok[1] == 'N' or re.match('ADJ', tok[1]) or re.match('V', tok[1]):
       keyList.append(tok)
   print keyList
   print len(keyList)
   return keyList

# 需要导入模块: from tagger import Tagger [as 别名]
# 或者: from tagger.Tagger import classify [as 别名]
 def gen_opt(self, file_text):
     '''
     método que gera o novo texto.
     cada palavra é classificada e concatenada com o tipo através do caractere /
     depois, é concatenado com o retorno do synset.
     '''
     tagger = Tagger('portugues')
     tok = word_tokenize(file_text.read().decode('utf-8'))
     clas = tagger.classify(tok)
     p_text = []
     for c in clas:
         if c[1] == 'N' or re.match('ADJ',c[1]) or re.match('V',c[1]) or c[1] == '.':
             gen_set = self.gen_synset(c)
             p_text.append(gen_set)
     optimized_text = ' '.join(p_text)
     return optimized_text

# 需要导入模块: from tagger import Tagger [as 别名]
# 或者: from tagger.Tagger import classify [as 别名]
class SearchEngine:
    """
    classe que considero a principal desse modulo. É a estrutura de dados que
    contém os arquivos para o processamento da engine.
    """
    def __init__(self):
        #  código para carregar o pickle
        self.search_data = {}
        self.load_data()
        #  carregando o tagger
        self.tagger = Tagger('portugues')

    def save(self):
        output = open('data.pkl', 'wb')
        dump(self.search_data, output)
        output.close()

    def insert(self, files):
        """
        Esse método tem como entrada um array de arquivos e uma tupla de path e
        retorna uma lista de indexação reversa.
        """
        for f in files:
            p_count = -1
            paragraph = sent_tokenize(f.read().decode('utf-8').lower())
            for p in paragraph:
                p_count +=1
                words = word_tokenize(p)
                classes = self.tagger.classify(words)
                for c in classes:
                    if re.match('N', c[1]):
                        if self.search_data.has_key(c[0]):
                            names = [n for n,_ in self.search_data[c[0]]]
                            if os.path.basename(f.name) in names:
                                self.search_data[c[0]][names.index(os.path.basename(f.name))][1].append(p_count)
                            else:
                                self.search_data[c[0]].append(((os.path.basename(f.name)),[p_count]))
                        else:
                            self.search_data.update({c[0]:[((os.path.basename(f.name)),[p_count])]})
        self.save()

    def search(self, name):
        """
        Algoritmo de busca simples que retorna um tupla com os arquivos.
        """
        if name in self.search_data:
            files = self.search_data[name]
            path_name = os.path.abspath('FriggAnswer')
            text_files = []
            if files is not None:
                for f in files:
                    text = open(path_name+'\\texts\\'+f[0]).read().decode('utf-8-sig')
                    opt_text = open(path_name+'\\texts2\\'+f[0]).read().decode('utf-8-sig').lower()
                    opt_text_data = GenSearchText().get_opt(opt_text)
                    #  tokenização
                    text_sent = sent_tokenize(text)
                    for i in f[1]:
                        element = (text_sent[i], opt_text_data[i]) #  modificado aqui
                        text_files.append(element)
            return set(text_files)
        else:
            return None

    def load_data(self):
        """
        função simples para carregar o arquivo
        """
        path = os.path.abspath('FriggAnswer')+'/pickle/'
        #path = os.path.abspath('pickle')+'\\'
        input_data = open(path + 'data.pkl')
        self.search_data = load(input_data)
        input_data.close()