def __init__(self, text):
self.doc = Doc(text)
self.doc.segment(Segmenter())
self.doc.tag_morph(NewsMorphTagger(NewsEmbedding()))
morph_vocab = MorphVocab()
for token in self.doc.tokens:
token.lemmatize(morph_vocab)
self.doc.parse_syntax(NewsSyntaxParser(NewsEmbedding()))
self.doc.tag_ner(NewsNERTagger(NewsEmbedding()))
for span in self.doc.spans:
span.normalize(morph_vocab)
self.words = tuple(filter(lambda x: x.pos not in ('X', 'PUNCT'), self.doc.tokens))
self.tokens_nouns = tuple(filter(lambda t: t.pos in ['NOUN', 'PROPN'], self.doc.tokens))
self.tokens_adjs = tuple(filter(lambda t: t.pos == 'ADJ', self.doc.tokens))
self.tokens_verbs = tuple(filter(lambda t: t.pos == 'VERB', self.doc.tokens))
def __init__(self):
self.morph = pymorphy2.MorphAnalyzer()
self.segmenter = Segmenter()
self.morph_vocab = MorphVocab()
self.emb = NewsEmbedding()
self.morph_tagger = NewsMorphTagger(self.emb)
self.ner_tagger = NewsNERTagger(self.emb)
def __init__(self):
self.segmenter = Segmenter()
self.morph_vocab = MorphVocab()
self.emb = NewsEmbedding()
self.morph_tagger = NewsMorphTagger(self.emb)
self.ner_tagger = NewsNERTagger(self.emb)
self.syntax_parser = NewsSyntaxParser(self.emb)
def __tag_text(text):
doc = Doc(text)
doc.segment(Segmenter())
ner_tagger = NewsNERTagger(NewsEmbedding())
doc.tag_ner(ner_tagger)
return doc
def __init__(self, syntax_model_name):
self.syntax_model_name = syntax_model_name
if syntax_model_name == 'deeppavlov':
self.model_deeppavlov = build_model(
configs.syntax.syntax_ru_syntagrus_bert, download=True)
elif syntax_model_name == 'natasha':
self.segmenter = Segmenter()
emb = NewsEmbedding()
self.syntax_parser = NewsSyntaxParser(emb)
else:
print('Выберите модель, автоматически выбрана модель deeppavlov')
self.syntax_model_name = 'deeppavlov'
self.model_deeppavlov = build_model(
configs.syntax.syntax_ru_syntagrus_bert, download=True)
self.conjunction = [
'и', 'да', 'ни-ни', 'тоже', 'также', 'а', 'но', 'зато', 'однако',
'же', 'или', 'либо', 'то-то', 'что', 'будто', 'чтобы', 'чтобы не',
'как бы не', 'когда', 'как только', 'лишь только', 'едва', 'пока',
'в то время как', 'после того как', 'потому что', 'так как', 'ибо',
'оттого что', ' из-за того что', 'вследствии того что', 'чтобы',
'для того чтобы', 'с тем чтобы', 'если', 'если бы', 'раз', 'коль',
'коли', 'хотя', 'сколько ни', 'когда ни', 'что ни', 'что бы ни',
'несмотря на то что', 'так что', 'вследствие того что', 'как',
'будто', 'как будто', 'точно', 'словно'
]
self.morph = pymorphy2.MorphAnalyzer()
self.like_root = ['acl:relcl', 'advcl', 'root', 'parataxis', 'ccomp']
self.can_be_root = ['nsubj', 'conj']
def __init__(self):
self.ner_model = build_model(configs.ner.ner_ontonotes_bert_mult,
download=False)
self.segmenter = Segmenter()
self.morph_vocab = MorphVocab()
self.emb = NewsEmbedding()
self.morph_tagger = NewsMorphTagger(self.emb)
def process_text_file(text_file, mongo=None):
# nlp = spacy.load('ru_core_news_sm')
segmenter = Segmenter()
emb = NewsEmbedding()
morph_tagger = NewsMorphTagger(emb)
syntax_parser = NewsSyntaxParser(emb)
with open(text_file, 'r', encoding='utf-8') as file:
file_name = file.name[2:]
line_number = 0
for line in file:
line_number += 1
if line_number % 100 == 0:
logging.info(f'Processed line {line_number}')
if line_number >= 100000:
return
sents = [sent.text for sent in sentenize(line)]
sentence_number = 0
for sentence in sents:
doc = Doc(sentence)
doc.segment(segmenter)
doc.tag_morph(morph_tagger)
doc.parse_syntax(syntax_parser)
sentence_number += 1
sentence_tokens = doc.tokens
# sentence_tokens = [
# {
# 'text': token.text,
# 'lemma': token.lemma_,
# 'pos': token.pos_,
# 'tag': token.tag_,
# 'dep': token.dep_,
# 'shape': token.shape_,
# 'is_alpha': token.is_alpha,
# 'is_stop': token.is_stop
# } for token in sentence]
words = markup_words(doc.syntax)
deps = token_deps(doc.syntax.tokens)
html = show_dep_markup(words, deps)
save_html(
html,
f'./htmls/dependency_plot_{file_name}_{line_number}_{sentence_number}.html'
)
#
# svg = displacy.render(sentence, style='dep', options={'compact': False, 'bg': '#09a3d5',
# 'color': 'white', 'font': 'Source Sans Pro'})
# output_path = Path(f'./images/dependency_plot_{file_name}_{line_number}_{sentence_number}.svg')
# output_path.open('w', encoding='utf-8').write(svg)
PatternExtractor.extract_relations(
file_name,
line_number,
sentence_number,
sentence,
sentence_tokens,
# noun_phrases,
# mongo=mongo
)
def calculate_skills_assessment(text, ca):
vacancy_key_skills = list(
map(
lambda x: x.lower(),
list(ca.core_vacancy.key_skills.all().values_list('title',
flat=True))))
vacancy_additional_skills = list(
map(
lambda x: x.lower(),
list(ca.core_vacancy.additional_skills.all().values_list(
'title', flat=True))))
segmenter = Segmenter()
emb = NewsEmbedding()
morph_tagger = NewsMorphTagger(emb)
syntax_parser = NewsSyntaxParser(emb)
morph_vocab = MorphVocab()
text = extract_text(ca.cv_file.path)
doc = Doc(text)
doc.segment(segmenter)
doc.tag_morph(morph_tagger)
doc.parse_syntax(syntax_parser)
cv_key_skills = []
cv_additional_skills = []
for token in doc.tokens:
token.lemmatize(morph_vocab)
print(token)
if token.lemma in vacancy_key_skills and token.lemma not in cv_key_skills:
cv_key_skills.append(token.lemma)
print(token.lemma)
if token.lemma in vacancy_additional_skills and token.lemma not in cv_additional_skills:
cv_additional_skills.append(token.lemma)
print(token.lemma)
candidate_conformity = {
"key_skills": {
"vacancy_key_skills": vacancy_key_skills,
"cv_key_skills": cv_key_skills,
"conformity_percent": len(cv_key_skills) / len(vacancy_key_skills)
},
"additional_skills": {
"vacancy_additional_skills":
vacancy_additional_skills,
"cv_additional_skills":
cv_additional_skills,
"conformity_percent":
len(cv_additional_skills) / len(vacancy_additional_skills)
}
}
return candidate_conformity
def __init__(self):
self.segmenter = Segmenter()
self.morph_vocab = MorphVocab()
self.emb = NewsEmbedding()
self.morph_tagger = NewsMorphTagger(self.emb)
self.syntax_parser = NewsSyntaxParser(self.emb)
self.ner_tagger = NewsNERTagger(self.emb)
self.names_extractor = NamesExtractor(self.morph_vocab)
self.doc = []
self.term_extractor = TermExtractor()
def process_russian_text(text, type_of_word_to_highlight='VERB'):
# check out the original source:
# https://github.com/natasha/natasha
segmenter = Segmenter()
emb = NewsEmbedding()
morph_tagger = NewsMorphTagger(emb)
doc = Doc(text)
doc.segment(segmenter)
doc.tag_morph(morph_tagger)
return [token.text for token in doc.tokens if token.pos == type_of_word_to_highlight]
def __init__(self):
self.replacer = ""
self.text_gender = 'masc'
self.setting_gender = 'auto'
self.syntax_map = []
self.segmenter = Segmenter()
self.emb = NewsEmbedding()
self.syntax_parser = NewsSyntaxParser(self.emb)
self.morph = pymorphy2.MorphAnalyzer(lang='ru',
path=resource_path('data/'))
self.stop = False
def preprocess_sent(incoming_sent):
doc = Doc(incoming_sent)
segmenter = Segmenter()
emb = NewsEmbedding()
morph_tagger = NewsMorphTagger(emb)
syntax_parser = NewsSyntaxParser(emb)
doc.segment(segmenter)
doc.tag_morph(morph_tagger)
doc.parse_syntax(syntax_parser)
return doc.sents[0]
def main():
parser = ArgumentParser()
parser.add_argument(
'--input_data_dir',
default=r"../../task_1/reviews/reviews",
type=str,
help="Директория непредобработанных текстов, в данном случае - отзывов"
)
parser.add_argument(
'--output_dir',
default=r"../tokenized_texts",
type=str,
help="Выходная директория, в которой будут содержаться словарь"
"и файл с лемматизированными текстами")
parser.add_argument('--output_dict_fname',
default=r"dict.txt",
type=str,
help="имя файла словаря")
parser.add_argument('--output_documents_fname',
default=r"documents.txt",
type=str,
help="Имя файла с лемматизированными документами")
args = parser.parse_args()
input_data_dir = args.input_data_dir
output_dir = args.output_dir
if not os.path.exists(output_dir) and output_dir != '':
os.makedirs(output_dir)
output_dict_fname = args.output_dict_fname
output_documents_fname = args.output_documents_fname
output_dict_path = os.path.join(output_dir, output_dict_fname)
output_documents_path = os.path.join(output_dir, output_documents_fname)
segmenter = Segmenter()
morph_vocab = MorphVocab()
emb = NewsEmbedding()
morph_tagger = NewsMorphTagger(emb)
# список списков лемм всех документов
lemmatized_tokens_lists = []
# словарь лемм
lemmas_dictionary = set()
for document_fname in sorted(os.listdir(input_data_dir),
key=lambda x: get_doc_id_word_key(x)):
document_path = os.path.join(input_data_dir, document_fname)
with codecs.open(document_path, 'r', encoding="utf-8") as review_file:
document_raw_text = review_file.read()
# получаем список лемм документа
lemmatized_tokens = get_lemmatized_doc(raw_text=document_raw_text,
segmenter=segmenter,
morph_tagger=morph_tagger,
morph_vocab=morph_vocab)
# Добавляем список лемм в список списков лемм всех документов
lemmatized_tokens_lists.append(lemmatized_tokens)
# обновляем словарь лемм
lemmas_dictionary.update(lemmatized_tokens)
# запись словаря в файл
with codecs.open(output_dict_path, 'w+', encoding="utf-8") as dict_file:
for token in lemmas_dictionary:
dict_file.write(f"{token}\n")
# Запись лемматизированных документов в файл
with codecs.open(output_documents_path, 'w+',
encoding="utf-8") as documents_file:
for doc_lemmas_list in lemmatized_tokens_lists:
documents_file.write(f"{' '.join(doc_lemmas_list)}\n")
def get_embedding(cls):
embedding = getattr(cls, "_embedding", None)
if not embedding:
embedding = NewsEmbedding()
cls._embedding = embedding
return embedding
if getattr(sys, 'frozen', False):
NEWS_EMBEDDING = os.path.join(sys._MEIPASS,
"navec_news_v1_1B_250K_300d_100q.tar")
NEWS_MORPH = os.path.join(sys._MEIPASS, "slovnet_morph_news_v1.tar")
NEWS_SYNTAX = os.path.join(sys._MEIPASS, "slovnet_syntax_news_v1.tar")
NEWS_NER = os.path.join(sys._MEIPASS, "slovnet_ner_news_v1.tar")
DICTS = os.path.join(sys._MEIPASS, "dicts")
else:
NEWS_EMBEDDING = os.path.join("navec_news_v1_1B_250K_300d_100q.tar")
NEWS_MORPH = os.path.join("slovnet_morph_news_v1.tar")
NEWS_SYNTAX = os.path.join("slovnet_syntax_news_v1.tar")
NEWS_NER = os.path.join("slovnet_ner_news_v1.tar")
DICTS = "dicts"
emb = NewsEmbedding(path=NEWS_EMBEDDING)
morph_tagger = NewsMorphTagger(emb, path=NEWS_MORPH)
segmenter = Segmenter()
syntax_parser = NewsSyntaxParser(emb, path=NEWS_SYNTAX)
ner_tagger = NewsNERTagger(emb, path=NEWS_NER)
NARRATOR = -1
DETPRON = {
"Fem": {
'3': ["ее", "её"],
'1': [
'мой', 'моя', 'моё', 'мое', 'мои', 'моего', 'моей', 'моих',
'моему', 'моим', 'мою', 'моим', 'моею', 'моими', 'моем', 'моём'
]
},
"Masc": {
def main():
parser = ArgumentParser()
parser.add_argument('--input_request_str',
default=r"Классическая литература",
type=str,
help="Строка поискового запроса")
parser.add_argument('--input_dict_path',
default=r"../task_2/tokenized_texts/dict.txt",
type=str,
help="Путь к словарю")
parser.add_argument(
'--input_df_path',
default="../task_4/tf_idf/df.txt",
type=str,
help=r"Путь до файла с документными частотами терминов."
r"Записываю DF в файл, потому что почему бы и нет, так нагляднее")
parser.add_argument(
'--input_tf_idf_path',
default="../task_4/tf_idf/tf_idf.txt",
type=str,
help=
r"Путь до файла cо значениями TF-IDF. Каждая строка соответствует одному"
r"документу. В строке пробелами разделены пары <термин, его idf, его tf-idf>,"
r"а термин и его tf-idf разделены строкой '~~~'")
parser.add_argument('--input_raw_documents_dir',
default=r"../task_1/reviews/reviews/",
type=str,
help="Путь к директории непредобработанных документов")
parser.add_argument('--output_log_path',
default=r"search_log.txt",
type=str,
help="Путь к файлу логов поисковых запросов")
args = parser.parse_args()
input_request_str = args.input_request_str
input_dict_path = args.input_dict_path
input_df_path = args.input_df_path
input_tf_idf_path = args.input_tf_idf_path
input_raw_documents_dir = args.input_raw_documents_dir
output_log_path = args.output_log_path
output_dir = os.path.dirname(output_log_path)
if not os.path.exists(output_dir) and output_dir != '':
os.makedirs(output_dir)
# Подгружаем словарь в память
token2id = load_dict(input_dict_path)
# Подгружаем предпосчитанную матрицу TF-IDF из файла
tf_idf_matrix = load_tf_idf_matrix_from_file(
tf_idf_file_path=input_tf_idf_path,
token2id=token2id,
)
num_documents = tf_idf_matrix.shape[0]
# Подгружаем инвертированные документные частоты терминов (IDF)
token_idfs = load_vocab_idfs(vocab_dfs_path=input_df_path,
token2id=token2id,
num_documents=num_documents)
segmenter = Segmenter()
morph_vocab = MorphVocab()
emb = NewsEmbedding()
morph_tagger = NewsMorphTagger(emb)
request_vector = vectorize_request_tf_idf(
request_raw_text=input_request_str,
segmenter=segmenter,
morph_tagger=morph_tagger,
morph_vocab=morph_vocab,
token2id=token2id,
token_idfs=token_idfs)
# Идентификатор документа, наиболее похожего на запрос векторно. Мера похожести - косинусная близость векторов
response_document_id = cosine_similarity(tf_idf_matrix,
request_vector).argmax()
# Путь до файла исходного непредобработанного документа
response_document_path = os.path.join(
input_raw_documents_dir, f"review_{response_document_id}.txt")
# Логируем результат выполнения запроса
write_request_log(log_file_path=output_log_path,
request_str=input_request_str,
response_document_id=response_document_id,
response_document_path=response_document_path)
def ca_details(request, ca_id):
ca = get_object_or_404(CandidateApplication, id=ca_id)
vacancy_key_skills = list(
map(
lambda x: x.lower(),
list(ca.core_vacancy.key_skills.all().values_list('title',
flat=True))))
vacancy_additional_skills = list(
map(
lambda x: x.lower(),
list(ca.core_vacancy.additional_skills.all().values_list(
'title', flat=True))))
segmenter = Segmenter()
emb = NewsEmbedding()
morph_tagger = NewsMorphTagger(emb)
syntax_parser = NewsSyntaxParser(emb)
morph_vocab = MorphVocab()
text = extract_text(ca.cv_file.path)
doc = Doc(text)
doc.segment(segmenter)
doc.tag_morph(morph_tagger)
doc.parse_syntax(syntax_parser)
cv_key_skills = []
cv_additional_skills = []
for token in doc.tokens:
token.lemmatize(morph_vocab)
print(token)
if token.lemma in vacancy_key_skills and token.lemma not in cv_key_skills:
cv_key_skills.append(token.lemma)
print(token.lemma)
if token.lemma in vacancy_additional_skills and token.lemma not in cv_additional_skills:
cv_additional_skills.append(token.lemma)
print(token.lemma)
candidate_conformity = {
"key_skills": {
"vacancy_key_skills": vacancy_key_skills,
"cv_key_skills": cv_key_skills,
"conformity_percent": len(cv_key_skills) / len(vacancy_key_skills)
},
"additional_skills": {
"vacancy_additional_skills":
vacancy_additional_skills,
"cv_additional_skills":
cv_additional_skills,
"conformity_percent":
len(cv_additional_skills) / len(vacancy_additional_skills)
}
}
return render(request,
'demo_data.html',
context={'data': json.dumps(candidate_conformity)})
def embedding():
return NewsEmbedding()
from tensorflow.keras.layers import Dense, Dropout, Bidirectional, GlobalMaxPooling1D, Input, Activation, concatenate, GlobalAveragePooling1D, GRU
import gensim
from sklearn.preprocessing import OneHotEncoder
from sklearn.model_selection import train_test_split
from natasha import Segmenter, NewsEmbedding, PER, MorphVocab, NewsMorphTagger, Doc
from helpers import to_serializable, make_keras_picklable
app = Flask(__name__)
STOP_WORDS = set(open('stop_words.txt', encoding='utf-8').read().split())
# для токенизации
segmenter = Segmenter()
morph_vocab = MorphVocab()
emb = NewsEmbedding()
morph_tagger = NewsMorphTagger(emb)
# max sentence length
WORD_LIMIT = 10
EMBEDDING_DIM = 300
INTENTS_URL = 'http://localhost:6969/intents'
# load intents from json
def load_labels():
labels = []
url = INTENTS_URL
try:
def Main(docType, text):
status = 1
res = {}
segmenter = Segmenter()
emb = NewsEmbedding()
morph_tagger = NewsMorphTagger(emb)
syntax_parser = NewsSyntaxParser(emb)
ner_tagger = NewsNERTagger(emb)
morph_vocab = MorphVocab()
names_extractor = NamesExtractor(morph_vocab)
money_extractor = MoneyExtractor(morph_vocab)
doc = Doc(text)
doc.segment(segmenter)
doc.tag_morph(morph_tagger)
doc.parse_syntax(syntax_parser)
doc.tag_ner(ner_tagger)
for span in doc.spans:
span.normalize(morph_vocab)
#для судебного приказа
if docType == 'coast':
#фио
for span in doc.spans:
if span.type == PER:
span.extract_fact(names_extractor)
x = [_.fact.as_dict for _ in doc.spans if _.type == PER]
if x:
res['ФИО'] = x
else:
status = 0
#инн
y = myextractors.findINN(text)
if y:
res['ИНН'] = y
else:
status = 0
#номер судебного приказа
y = myextractors.findNCOASTCASE(text)
if y:
res['номер судебного приказа'] = y
else:
status = 0
#дата с п
y = myextractors.findDATECOAST(text)
if y:
res['дата судебного приказа'] = y
else:
status = 0
#организации
y = []
for span in doc.spans:
if span.type == ORG:
d = {}
d['name'] = span.text
y = y + [d]
if y:
res['организации'] = y
else:
status = 0
#для письма
if docType == 'mail':
#фио
for span in doc.spans:
if span.type == PER:
span.extract_fact(names_extractor)
x = [_.fact.as_dict for _ in doc.spans if _.type == PER]
if x:
res['ФИО'] = x
else:
status = 0
#инн
y = myextractors.findINN(text)
if y:
res['ИНН'] = y
else:
status = 0
#номер дог
y = myextractors.findNCONTRACT(text)
if y:
res['номер договора'] = y
else:
status = 0
#дата дог
y = myextractors.findDATECONT(text)
if y:
res['дата договора'] = y
else:
status = 0
#для платежного поручения
if docType == 'order':
#фио
for span in doc.spans:
if span.type == PER:
span.extract_fact(names_extractor)
x = [_.fact.as_dict for _ in doc.spans if _.type == PER]
if x:
res['ФИО'] = x
else:
status = 0
#инн
y = myextractors.findINN(text)
if y:
res['ИНН'] = y
else:
status = 0
#организации
y = []
for span in doc.spans:
if span.type == ORG:
d = {}
d['name'] = span.text
y = y + [d]
if y:
res['организации'] = y
else:
status = 0
#номер дог
y = myextractors.findNCONTRACT(text)
if y:
res['номер договора'] = y
else:
status = 0
#дата дог
y = myextractors.findNCONTRACT(text)
if y:
res['номер договора'] = y
else:
status = 0
#сумма
matches = list(money_extractor(text))
y = [_.fact for _ in matches]
ret = []
for i in y:
z = {}
z['amount'] = i.amount
z['currency'] = i.currency
ret = ret + [z]
if ret:
res['сумма'] = ret
else:
status = 0
returning = {}
if status == 1:
returning['status'] = 'успех'
else:
returning['status'] = 'не успех'
returning['entities'] = res
return returning
