def generateCategoryAndPublisher(self):
for x in xrange(0,len(allowCategory)*len(publisherList)):
self.corporaDict.append(corpora.Dictionary())
# for category, publisher, content in self.docs:
# self.corporaDict[int(category)*len(publisherList)+publisherToNum(publisher)].add_documents([content])
count = 0
cate_count = 0
publisher_count = 0
for dictionary in self.corporaDict:
# once_ids = [tokenid for tokenid, docfreq in dictionary.dfs.iteritems() if docfreq <= 5]
# dictionary.filter_tokens(once_ids)
# dictionary.compactify()
# dictionary.save('./'+ str(cate_count)+ "_" + str(publisher_count) +'.dict')
self.corporaDict[count] = corpora.Dictionary.load('./'+ str(cate_count)+ "_" + str(publisher_count) +'.dict')
# dc = DocCorpus(Docs(self.docsURL,cate_count,publisher_count), dictionary)
# tfidf = models.TfidfModel(dc)
# tfidf.save('./'+ str(cate_count)+ "_" + str(publisher_count) +'.tfidf_model')
# index = Similarity(corpus=tfidf[dc], num_features=tfidf.num_nnz, output_prefix=(str(cate_count)+ "_" + str(publisher_count)),num_best=50)
# self.index.append(index)
# index.save('./'+ str(cate_count)+ "_" + str(publisher_count) +'.sim')
self.index.append(Similarity.load('./'+ str(cate_count)+ "_" + str(publisher_count) +'.sim'))
publisher_count+=1
count+=1
if publisher_count == 3:
publisher_count = 0
cate_count+=1
def testar_modelo(self, modelo, vetor_testes, sucesso=100):
'''
Realiza testes no modelo, buscando a similaridade da dupla de teste.
Parâmetros:
modelo (str) --> Nome do modelo que se deseja pesquisar
vetor_testes (tuple (str, str)) --> Dupla de fichas, sendo a primeira o argumento de pesquisa e a segunda a ficha
cuja semelhança se espera encontrar
sucesso (int) --> Posição máxima na qual pode estar a ficha cuja semelhança se deseja encontrar para ser considerado
que o modelo obteve sucesso na pesquisa (default: 100)
Retorno: um DataFrame Pandas com as seguintes colunas:
* query --> A ficha que foi usada para fazer a pesquisa de semelhança (str)
* target --> A ficha que foi procurada no resultado da pesquisa (str)
* ordem --> A posição na qual a ficha target foi encontrada (int)
* per_sim --> A probabilidade de semelhança apontada pelo modelo (float)
* sucesso --> Indicador de sucesso ou não da pesquisa (boolean)
'''
# Obtém a matriz de similaridade do modelo
index = Similarity.load(self._arqs['indices'][modelo])
# Inicia o dicionário que será usado para montar o DataFrame
resultados = {
'query': [],
'target': [],
'ordem': [],
'per_sim': [],
'sucesso': []
}
# Percorre o vetor de testes para realizar as pesquisas
for query, target in vetor_testes:
resultados['query'].append(query)
resultados['target'].append(target)
id_query = self.corpus.ficha2id(query)
id_target = self.corpus.ficha2id(target)
posicao, per_sim = self._obter_posicao_target(
index, id_query, id_target)
resultados['ordem'].append(posicao)
resultados['per_sim'].append(per_sim)
resultados['sucesso'].append(posicao <= sucesso)
return pd.DataFrame(data=resultados)
tfidf_model = models.TfidfModel.load("model/pat_tfidf.model")
lsi_model = models.LsiModel.load("model/pat_lsi.model")
# corpus_lsi_simi_matrix = similarities.MatrixSimilarity(lsi_model[corpus_tfidf])
print "LSI MODEL BEGIN LOAD"
# print index
compare_file = "abstract9755578/pat_lsi2vec.txt"
if (os.path.exists(compare_file)):
raise Exception("Please delete compare_file first")
lsiwriter = open(compare_file, "a")
file_index = 0
current = 0
for file_index in range(0, 100):
index_file = "index_lsi/sim.index." + str(file_index)
if (os.path.exists(index_file)):
index = Similarity.load(index_file)
print index
print " SIMS BEGIN COMPARE: Index" + str(file_index)
inferred_vector = dictionary.doc2bow(
abstract9755578.lower().split())
print inferred_vector
inferred_vector_tfidf = tfidf_model[inferred_vector]
print inferred_vector_tfidf
inferred_vector_lsi = lsi_model[inferred_vector_tfidf]
print inferred_vector_lsi
test_lsi_simi = index[inferred_vector_lsi]
length = len(list(test_lsi_simi))
print length
for i in range(0, length):
rank = list(test_lsi_simi)[i]
line = i + current
def semelhantes(self, id_ficha_query, teste=False):
'''
Pesquisa no corpus quais fichas tem características mais semelhantes às da ficha indicada.
Parâmetros:
id_ficha_query (int) --> Identificador da ficha que servirá de comparação para buscar as semelhantes
Retorno: um Pandas DataFrame na ordem decrescente de semelhança das fichas
'''
primeiro = True
for modelo in self._modelos:
# Obtém o peso do modelo
peso = self._modelos[modelo]['peso']
# Obtém a matriz de similaridade do modelo
index = Similarity.load(self._arqs['indices'][modelo])
sims = index.similarity_by_id(id_ficha_query)
# Cria um dicionário com o resultado da query para o modelo
sims_dict = {'ficha': [], 'per_sim': [], 'peso': []}
for id_ficha, per_sim in enumerate(sims):
if id_ficha == id_ficha_query: continue
if not teste and per_sim < self._modelos[modelo]['min_per_sim']:
continue
sims_dict['ficha'].append(id_ficha)
sims_dict['per_sim'].append(round(per_sim * 100, 2))
sims_dict['peso'].append(peso)
# Monta o DataFrame com o resultado da query
# Se não for o primeiro modelo, junta com o resultado anterior
if primeiro:
resultado = pd.DataFrame(data=sims_dict)
resultado.set_index('ficha', inplace=True)
resultado.columns = pd.MultiIndex.from_product(
[[modelo], ['per_sim', 'peso']])
resultado.sort_values(by=(modelo, 'per_sim'),
ascending=False,
inplace=True)
resultado[(modelo, 'ordem')] = [
i for i in range(1, resultado.shape[0] + 1)
]
resultado = resultado.astype({(modelo, 'ordem'): 'int64'})
primeiro = False
else:
parcial = pd.DataFrame(data=sims_dict)
parcial.set_index('ficha', inplace=True)
parcial.columns = pd.MultiIndex.from_product(
[[modelo], ['per_sim', 'peso']])
parcial.sort_values(by=(modelo, 'per_sim'),
ascending=False,
inplace=True)
parcial[(modelo, 'ordem')] = [
i for i in range(1, parcial.shape[0] + 1)
]
parcial = parcial.astype({(modelo, 'ordem'): 'int64'})
resultado = resultado.join(parcial, how='outer')
# Preenches com zeros os valores não encontrados em cada modelo
resultado.fillna(0, inplace=True)
# Calcula a probabilidade geral com base no peso de cada modelo e ordena por esse valor em ordem decrescente
geral = ('geral', 'per_sim')
resultado[geral] = [0 for i in range(resultado.shape[0])]
peso_total = 0
for modelo in self._modelos:
resultado[geral] = resultado[geral] + (resultado[
(modelo, 'per_sim')] * resultado[(modelo, 'peso')])
peso_total += self._modelos[modelo]['peso']
resultado[geral] = round(resultado[geral] / peso_total, 2)
resultado.sort_values(by=geral, ascending=False, inplace=True)
resultado[('geral',
'ordem')] = [i for i in range(1, resultado.shape[0] + 1)]
return resultado
