def try1():
G = nx.MultiGraph()
path = r"test_books\1.zip"
xml = bm.open_book(path)
_xpath = etree.XPath(r'//*')
dom = etree.XML(xml)
ans = _xpath(dom)
for i in ans:
"""Обработка заголовков, автора и т.д. через i.text """
if re.search(r"\b[p]", i.tag): # предполагаю, что строки с текстом заканчиваются на p
""" Построчная обработка книги перед предпроцессингом (Только текста) """
if not i.text:
continue
sintax = get_sintax(i.text)
add_to_graph(sintax, G)
keys = []
for key in G:
if not G[key]:
keys.append(key)
for key in keys:
G.remove_node(key)
# for i in range(10):
# print(combined_model.make_sentence(tries=30))
node_color = [G.degree(v)/10 for v in G]
print(node_color)
# node_size = [0.0005 * nx.get_node_attributes(G, 'population')[v] for v in G]
nx.draw(G, nlist=[G.nodes], with_labels=True, node_color=node_color, font_color="k")
plt.show()
def compressing():
for num in range(32800, 40000):
path = r"test_books\%s.zip" % str(num)
try:
book = open_book(path) # Проверка нормальный ли файл
plc_path = r'graph_models\{}_graph.plc'.format(str(num))
book_dict = BL.compress_book(path)
print(num, book_dict)
with open(plc_path, 'wb') as f:
pickle.dump(book_dict, f)
except zipfile.BadZipFile:
continue
def new_book_analys(self, path):
"""Обнуление переменных на случай, если была загружена прошлая книга"""
self.book_strings = []
self.counter = Counter([])
self.swear_set = set()
self.avd_word_counter = 0
self.verb_now = 0
self.noun_now = 0
self.adv_now = 0
self.verb_list = []
self.noun_list = []
self.adv_list = []
xml = bm.open_book(path)
print()
print()
print(xml.decode())
print()
print()
_xpath = etree.XPath(r'//*')
dom = etree.XML(xml)
ans = _xpath(dom)
for i in ans:
"""Обработка заголовков, автора и т.д. через i.text """
if re.search(r"\b[p]", i.tag): # предполагаю, что строки с текстом заканчиваются на p
""" Построчная обработка книги перед предпроцессингом (Только текста) """
p_text = self.preprocess_text(self, i.text) # Обработка каждой строки книги
""" Построчная обработка после предпроцессинга (Только текста)"""
self.get_structure(p_text)
print(self.counter)
""" Работа с вторичными данными"""
self.swear_set = self.swear_counter(self.counter)
x_plt = [i for i in range(self._avd_quantity, len(self.noun_list)*self._avd_quantity+1, self._avd_quantity)]
plt = vis.f_plot(x_plt, self.noun_list, x_plt, self.verb_list, x_plt, self.adv_list, colors=["red", "green", "blue"], plot_names=['Сущ.', 'Глаголы', "Прил."])
plt.show()
for word in sintax:
if len(word) > 0 and word[0] != "#":
word = word.replace(" ", " ").split()
if word[6] == "0":
continue
graph.add_edge(sintax_dict[word[6]], word[2], context=word[6])
from UDPipe_api import *
import networkx as nx
G = nx.MultiGraph()
path = r"test_books\slugi.zip"
xml = bm.open_book(path)
_xpath = etree.XPath(r'//*')
dom = etree.XML(xml)
ans = _xpath(dom)
for i in ans[200:300]:
"""Обработка заголовков, автора и т.д. через i.text """
if re.search(
r"\b[p]",
i.tag): # предполагаю, что строки с текстом заканчиваются на p
""" Построчная обработка книги перед предпроцессингом (Только текста) """
sintax = get_sintax(i.text)
add_to_graph(sintax, G)
# for i in range(10):
# print(combined_model.make_sentence(tries=30))
r"\b[p]",
i.tag): # предполагаю, что строки с текстом заканчиваются на p
if not i.text:
continue
""" Построчная обработка книги перед предпроцессингом (Только текста) """
sintax = udpipe_obj.get_sintax(i.text)
sintax_list.append(sintax)
return sintax_list
if __name__ == '__main__':
udpipe = UDPipe()
for book_num in range(0, 100000):
book_path = r'E:\books\flibusta_' + str(book_num) + '.zip'
try:
book_xml = book_manager.open_book(book_path)
book_info = get_base_info_from_book_xml(book_xml)
print(book_num, book_info)
# rating = LitresParser.get_rating(book_info['author_name'] + " " + book_info['author_second_name'],
# book_info['title'])
# print(rating)
sintax_list = get_sintax_list(udpipe, book_xml)
sintax_save_path = r"E:\sintax_lists\sintax_flibusta_" + str(
book_num) + '.plc'
with open(sintax_save_path, 'wb') as f:
clf = pickle.dump(sintax_list, f)
print("Сохранено :) ")
except zipfile.BadZipFile:
# book = open(book_path, 'r', encoding='utf8')
continue # Там есть полезная инфа, но книги нет
except BookNotFound:
def compress_book(path):
UD = udpipe.UDPipe()
G = nx.MultiGraph()
xml = bm.open_book(path)
_xpath = etree.XPath(r'//*')
dom = etree.XML(xml)
ans = _xpath(dom)
author = dict()
book_title = None
sintax_time = time.time()
# Создаем первичный граф
for i in ans[:100]: # TODO Распаралелить?
"""Обработка заголовков, автора и т.д. через i.text """
if re.search(
r"\b[p]",
i.tag): # предполагаю, что строки с текстом заканчиваются на p
if not i.text:
continue
""" Построчная обработка книги перед предпроцессингом (Только текста) """
text_list = i.text.split(". ")
for text in text_list:
sintax = UD.get_sintax(text)
add_to_graph(sintax, G)
else:
if re.search(r"\blast-name",
i.tag) and author.get('last', None) is None:
author["last"] = i.text
if re.search(r"\bmiddle-name",
i.tag) and author.get('middle', None) is None:
author["middle"] = i.text
if re.search(r"\bfirst-name",
i.tag) and author.get('first', None) is None:
author["first"] = i.text
if re.search(r"\bbook-title", i.tag) and book_title is None:
book_title = i.text
print(book_title)
author_str = author.get('last', "")
if author_str:
if author.get('first', ""):
author_str += ' ' + author['first'][:1].upper() + "."
if author.get('middle', ""):
author_str += author['middle'][:1].upper() + "."
print(author_str)
print("Время обработки синтаксиса из {} равно {}".format(
str(len(ans)), str(time.time() - sintax_time)))
# with open(r"sintax_models\slugi_sintax_dict.plk", 'wb') as f:
# pickle.dump(sintax_dict, f)
# Граф собран - дальше постобработка
# Объединим синонимы
sintax_time = time.time()
G = combine_synonims(G)
print("Время обработки синонимов для {} равно {}".format(
str(len(G)), str(time.time() - sintax_time)))
# убираем указательные местоимения
sintax_time = time.time()
G = delete_target_pronouns(G)
print("Время обработки местоимений для {} равно {}".format(
str(len(G)), str(time.time() - sintax_time)))
# Удаляем одинокие вершины
keys = []
for key in G:
if not G[key]:
keys.append(key)
for key in keys:
G.remove_node(key)
return {"book_title": book_title, "author": author_str, "graph": G}
def try4():
G = nx.MultiGraph()
clf = train_logistic_regression(300, "person_train", const.person_list, const.non_person_list)
path = r"test_books\slugi.zip"
path = r"test_books\1.zip"
xml = bm.open_book(path)
_xpath = etree.XPath(r'//*')
dom = etree.XML(xml)
ans = _xpath(dom)
for i in ans:
"""Обработка заголовков, автора и т.д. через i.text """
if re.search(r"\b[p]", i.tag): # предполагаю, что строки с текстом заканчиваются на p
if not i.text:
continue
""" Построчная обработка книги перед предпроцессингом (Только текста) """
sintax = get_sintax(i.text)
add_to_graph4(sintax, G)
# Граф собран - дальше постобработка
keys = [] # Удалим вершины без ребер
for key in G:
if not G[key]:
keys.append(key)
for key in keys:
G.remove_node(key)
# Обединим синонимы
noun_word_list = []
noun_vec_list = []
verb_word_list = []
verb_vec_list = []
for word in G: # Соберем вектора для объединения синонимов
if is_pronoun(word): # Метоимения не объединяем
continue
token_word = tokenizer.get_stat_token_word(morph, word)
if token_word is None:
continue
vec = client.get_vec(token_word)
if len(vec) == 0:
continue
if token_word.find("NOUN") != -1: # Пока объединим только существительные
noun_word_list.append(word)
noun_vec_list.append(vec)
if token_word.find("VERB") != -1: # объединяем глаголы
verb_word_list.append(word)
verb_vec_list.append(vec)
size = len(noun_vec_list)
for base in range(size): # Объединяем синонимы существительныз
for comp in range(base+1, size):
if cosine(noun_vec_list[base], noun_vec_list[comp]) < 0.5:
old_name1 = noun_word_list[base]
old_name2 = noun_word_list[comp]
if old_name1 == old_name2:
continue
new_vec = (noun_vec_list[base] + noun_vec_list[comp]) / 2
res = json.loads(client.get_word_by_vec(new_vec.tostring()).decode())["res"][0]
new_name = res[0].split("_")[0]
combine_nodes(old_name1, old_name2, new_name, G)
for word in range(len(noun_word_list)):
if noun_word_list[word] in [old_name1, old_name2]:
noun_word_list[word] = new_name
size = len(verb_vec_list)
for base in range(size): # Объединяем синонимы глаголов
for comp in range(base+1, size):
if cosine(verb_vec_list[base], verb_vec_list[comp]) < 0.5:
old_name1 = verb_word_list[base]
old_name2 = verb_word_list[comp]
if old_name1 == old_name2:
continue
new_vec = (verb_vec_list[base] + verb_vec_list[comp]) / 2
res = json.loads(client.get_word_by_vec(new_vec.tostring()).decode())["res"][0]
new_name = res[0].split("_")[0]
combine_nodes(old_name1, old_name2, new_name, G)
for word in range(len(verb_word_list)):
if verb_word_list[word] in [old_name1, old_name2]:
verb_word_list[word] = new_name
# убираем указательные местоимения
target_pronouns = ["ты", "вы", "он", "она", "они"]
story_hystory = nx.get_edge_attributes(G, "story_time")
print(story_hystory)
for pron in target_pronouns: # Пробегаемся по местоимениям
if pron not in G.nodes:
continue
pron_edges = list(G[pron].keys())
for base_edge in pron_edges: # берем все их связи
if is_pronoun(base_edge) or is_continue_word(base_edge): # Связи с проходными словами и метоимениями можно не учитывать
continue
min_person = None
person = None
st_time = None
for q in range(10000):
if (pron, base_edge, q) in story_hystory.keys():
st_time = story_hystory[(pron, base_edge, q)]
if (base_edge, pron, q) in story_hystory.keys():
st_time = story_hystory[(base_edge, pron, q)]
if st_time is not None:
break
if st_time is None:
# print(G[base_edge])
# for line in story_hystory: # Когда объединяли синонимы - мы выкидывали время в сюжете
# if line[0] == base_edge or line[1] == base_edge:
# print(line)
continue
for edge in story_hystory: # Ищем ближайшего персонажа к данному
for word in edge[:2]:
if is_pronoun(word):
continue
token_word = tokenizer.get_stat_token_word(morph, word)
if token_word is None or token_word.find("NOUN") == -1:
continue
vec = client.get_vec(token_word)
if vec is None or len(vec) == 0:
continue
is_person = clf.predict(vec.reshape(1, -1))
if is_person != 0:
continue
dist = math.fabs(story_hystory[edge]-st_time)
if story_hystory[edge] < st_time:
dist /= 2
if min_person is None or dist < min_person:
min_person = math.fabs(story_hystory[edge]-st_time)
person = word
replace_edge(pron, base_edge, person, G)
for pron in target_pronouns:
if pron in G.nodes:
G.remove_node(pron)
# i_do = G["я"].keys()
# max_inter = 0
# max_key = None
# for key in G.nodes:
# if len(G[key].keys() & i_do)/len(G[key].keys() | i_do) > max_inter and not is_pronoun(key):
# max_key = key
# max_inter = len(G[key].keys() & i_do)/len(G[key].keys() | i_do)
#
# print(max_key)
# print((G[max_key].keys() & i_do))
keys = []
for key in G:
if not G[key]:
keys.append(key)
for key in keys:
G.remove_node(key)
persons = []
per_vec = []
for node in G.nodes:
token_word = tokenizer.get_stat_token_word(morph, node)
if token_word is None or token_word.find("NOUN") == -1:
continue
vec = client.get_vec(token_word)
if vec is None or len(vec) == 0:
continue
is_person = clf.predict(vec.reshape(1, -1))
if is_person == 0:
test_v = tokenizer.get_stat_token_word(morph, "налогоплательщик")
test_vec = client.get_vec(test_v)
print(node, cosine(test_vec, vec))
persons.append(node)
per_vec.append(vec)
print("persons = ", persons)
print()
for i in persons:
print(i)
test_v = tokenizer.get_stat_token_word(morph, "налогоплательщик")
test_vec = client.get_vec(test_v)
s = 1
for vec in per_vec:
s *= cosine(test_vec, vec)
print(cosine(test_vec, vec))
s ** (1/len(persons))
print(s)
for per in persons:
print(per, G[per])
print()
for per in G["человек"]:
token_word = tokenizer.get_stat_token_word(morph, per)
print(token_word)
node_color = [(G.degree(v))*3 for v in G]
node_size = [400 * nx.get_node_attributes(G, 'size')[v] for v in G]
#print(nx.get_node_attributes(G, 'size'))
nx.draw(G, nlist=[G.nodes], with_labels=True, node_color=node_color, font_color="k", node_size=node_size)
plt.show()
def try3():
G = nx.MultiGraph()
path = r"test_books\slugi.zip"
xml = bm.open_book(path)
_xpath = etree.XPath(r'//*')
dom = etree.XML(xml)
ans = _xpath(dom)
for i in ans[599:600]:
"""Обработка заголовков, автора и т.д. через i.text """
if re.search(r"\b[p]", i.tag): # предполагаю, что строки с текстом заканчиваются на p
""" Построчная обработка книги перед предпроцессингом (Только текста) """
sintax = get_sintax(i.text)
add_to_graph3(sintax, G)
keys = []
for key in G:
if not G[key]:
keys.append(key)
for key in keys:
G.remove_node(key)
# for i in range(10):
# print(combined_model.make_sentence(tries=30))
noun_word_list = []
noun_vec_list = []
verb_word_list = []
verb_vec_list = []
for word in G: # Соберем вектора
token_word = tokenizer.get_stat_token_word(morph, word)
if token_word is None:
continue
vec = client.get_vec(token_word)
if len(vec) == 0:
continue
if token_word.find("NOUN") != -1: # Пока объединим только соществительные
noun_word_list.append(word)
noun_vec_list.append(vec)
if token_word.find("VERB") != -1: # Пока объединим только соществительные
verb_word_list.append(word)
verb_vec_list.append(vec)
size = len(noun_vec_list)
for base in range(size):
for comp in range(base+1, size):
if cosine(noun_vec_list[base], noun_vec_list[comp]) < 0.5:
# print(noun_word_list[base], noun_word_list[comp])
old_name1 = noun_word_list[base]
old_name2 = noun_word_list[comp]
if old_name1 == old_name2:
continue
new_vec = (noun_vec_list[base] + noun_vec_list[comp]) / 2
# print(new_vec)
res = json.loads(client.get_word_by_vec(new_vec.tostring()).decode())["res"][0]
new_name = res[0].split("_")[0]
# print(new_name)
# new_name = old_name1 + old_name2
combine_nodes(old_name1, old_name2, new_name, G)
for word in range(len(noun_word_list)):
if noun_word_list[word] in [old_name1, old_name2]:
noun_word_list[word] = new_name
size = len(verb_vec_list)
for base in range(size):
for comp in range(base+1, size):
if cosine(verb_vec_list[base], verb_vec_list[comp]) < 0.5:
old_name1 = verb_word_list[base]
old_name2 = verb_word_list[comp]
if old_name1 == old_name2:
continue
new_vec = (verb_vec_list[base] + verb_vec_list[comp]) / 2
# print(new_vec)
res = json.loads(client.get_word_by_vec(new_vec.tostring()).decode())["res"][0]
new_name = res[0].split("_")[0]
# new_name = old_name1 + old_name2
combine_nodes(old_name1, old_name2, new_name, G)
for word in range(len(verb_word_list)):
if verb_word_list[word] in [old_name1, old_name2]:
verb_word_list[word] = new_name
keys = []
for key in G:
if not G[key]:
keys.append(key)
for key in keys:
G.remove_node(key)
node_color = [G.degree(v)*3 for v in G]
# print(G["я"])
# for word in G["я"]:
# if len(G[word]) > 1:
# print(G[word])
node_size = [400 * nx.get_node_attributes(G, 'size')[v] for v in G]
print(nx.get_node_attributes(G, 'size'))
nx.draw(G, nlist=[G.nodes], with_labels=True, node_color=node_color, font_color="k", node_size=node_size)
plt.show()