На пути к автоматическому упрощению текстов на русском языке

#print(self.lexem, target.lexem, self.pos, target.pos)

subst_query = str(self.lexem+'_'+self.pos)

target_query = str(context.lexem+'_'+context.pos)

if subst_query in model and target_query in model:

return model.similarity(subst_query, target_query)

else:

return 0.0

· Код, формирующий списков объектов класса Трудное слово:

class Complex_word(Token):

def __init__(self, w):

super().__init__(w)

self.substituts = None

self.place = None

self.context = None

self.easier = []

# список замен, в зависимости от выбранной базы

def search_substituts(self, base_type='model'):

# поиск по модели

def model_search(lexem, pos):

query = str(lexem+'_'+pos)

#print(query)

if query in model:

# формируем список квазисинонимов той же части речи

# при этом превращаем их в объекты соответствующего класса

syn_tokens = []

for syn, sim in model.most_similar(positive=[query]):

syn_text = syn[:syn.find('_')] # текст до части речи

syn_tok = Substitution(syn_text) # из текстовой строки инициализируем объект класса

syn_tok.pos = syn[syn_tok.len+1:] # часть речи

syn_tok.complexity_params(complexity_type) # сложность по функции в зависимости от выбранного параметра



syn_tok.similarity = sim # а близость по параметру модели

syn_tokens.append(syn_tok)

return syn_tokens

else:

return []

# поиск по YARN

def yarn_search(target, filepath = 'yarn-synsets1.csv'):

with open(filepath, "r", newline="") as file: # постепенный просмотр файла с синсетами (множествами синонимов)

reader = csv.DictReader(file, delimiter=';')

lst = []

for i,row in enumerate(reader):

cur_line = row['words'].split(';') # считываем колонку с синсетами

if len(cur_line)>1:

if target.lexem in cur_line:

del(reader)

for c in cur_line:

if ' ' not in c and c!=target.lexem: # формируем список однословных синонимов

sub_tok = Substitution(c)

sub_tok.setting_atr(target)

if sub_tok not in lst:

lst.append(sub_tok)

#TODO: выделить неоднословные в отдельный класс и поискать их частотность по n-граммам?

break

#print(lst)

return lst

#поиск по ASIS

def asis_search(target):

if target.lexem in asis:

lst = []

for s in asis[target.lexem]:

if ' ' not in s: # формируем список однословных синонимов

sub_tok = Substitution(s)

sub_tok.setting_atr(target)

lst.append(sub_tok)

return lst

else:

return []

if base_type == 'model':

self.substituts = model_search(self.lexem, self.pos)

if base_type == 'yarn':

self.substituts = yarn_search(self)

if base_type == 'asis':

self.substituts = asis_search(self)

return self



def find_easier(self, use_min = use_min, use_threshold = True, threshold = global_threshold):

for sub in self.substituts:

if sub.complexity > self.complexity:

if (use_threshold and not sub.is_complex(threshold = threshold, use_min = use_min)) or (not use_threshold):

self.easier.append(sub)

return self

def make_window(self, tokens, window = 10):

context = [self]

left_ind = self.num-1

right_ind = self.num+1

ind = 0

# добавляем по одному слову слева и/или справа, пока не наберется window + само слово

while len(context)<window+1:

while left_ind >= 0:

left_w = tokens[left_ind]

left_ind-=1

# проверка, что это слово

if any(exception in left_w.lexem for exception in ['_PUNKTUATION_', '_SPACE_', '_UNK_']):

continue

else:

context[:0] = [left_w] #вставляем слово слева от цепочки

ind+=1 # индекс слова сдвигается

break

while right_ind < len(tokens):

right_w = tokens[right_ind]

right_ind+=1

# проверка, что это слово и что его нужно рассматривать как сложное (не нарицательное)

if any(exception in right_w.lexem for exception in ['_PUNKTUATION_', '_SPACE_', '_UNK_']):

continue

else:

context.append(right_w) # справа от цепочки

break

self.place = ind

self.context = context

return self

class Substitution(Token):

def __init__(self, w):

super().__init__(w)

self.similarity = None

self.fitness = None

self.closeness = None

# для слов из словаря и тезауруса: определяем тег пайморфи, переводим в формат universal - так быстрее, чем майстемом

def tagging(self, w):

tag = morph.parse(w)[0].tag.POS

if tag in pymorphy_tags:

return pymorphy_tags[tag]

else:

return 'X' # Х - universal тег для неизвестных слов



# приписываем недостающие атрибуты словам, взятым из словаря или тезауруса

def setting_atr(self, target):

self.pos = self.tagging(self.lexem)

self.complexity_params(complexity_type)

self.similarity = self.cos_sim(target)

def selecting_complex(tokens, base_type=['yarn','model','asis'][0], threshold = global_threshold, use_min = False, use_threshold=False):

complex_words = []

actualy_complex = []

to_simplify = []

for token in tokens:

if token.is_complex(threshold, use_min):

comp_token = Complex_word(token) # токен становится Сложным словом

comp_token.search_substituts(base_type=base_type)

complex_words.append(comp_token)

# код для принтов

'''

if comp_token.substituts:

for syn in comp_token.substituts:

print (comp_token.lexem, comp_token.complexity, base_type, ':', syn.lexem, syn.complexity, syn.similarity)

'''

if comp_token.substituts:

actualy_complex.append(comp_token)

comp_token.find_easier(threshold=threshold, use_min=True, use_threshold=use_threshold)

if comp_token.easier:

to_simplify.append(comp_token)

else:

complex_words.append(token)

return complex_words, actualy_complex, to_simplify

· Код, осуществляющий определение признаков семантического сходства, контекстуального сходства и контекстуальной вероятности для объектов класса Трудное слово и их упрощающих кандидатов, ранжирующий эти кандидаты на основе суммы их параметров. На выходе упрощённые тексты и таблица, характеризующая сгенерированные упрощающие кандидаты:

ngrams_dict = {0: {}, 1: unigrams, 2: bigrams, 3: trigrams}

def ngram_prob(ngram, n, use_log= False):

c1 = ' '.join(ngram[-n:]) # в числителе частота строки длины n

c2 = ' '.join(ngram[-n:-1]) # в знаменателе - строки без последнего символа

d = ngrams_dict.get(n) # для поиска числителя берем словарь n-грамм

d2 = ngrams_dict.get(n-1) # для поиска знаменателя - словарь n-1-грамм

V = len(d)

#len(ngrams_dict.get(n-1,len(unigrams))) # сглаживание лапласса: добавляем размер словаря знаменателя

p1 = d.get(c1,0)+1

p2 = d2.get(c2,0)+V

result = p1/p2



if use_log:

return math.log(p1)-math.log(p2)

else:

return p1/p2

def context_prob(ngrams, use_log= False):

if use_log:

p_context = 0.0

else:

p_context = 1.0

for ngram in ngrams:

p = ngram_prob(ngram, 3, use_log= use_log)

#print(ngram, p)

if use_log:

p_context+=p

else:

p_context*=p

return p_context

df = pd.read_csv('texts1.csv', sep='\t', encoding='utf-8')

def make_sample(n=15, mode=['random','first'][1], lst = None):

text_rubrics = df.filter(items=['texts', 'rubrics']) # таблица текст-рубрика

text_for_potential = []

for r in rubrics:

rub_texts = []

for l in range(len(text_rubrics)):

if text_rubrics.loc[l][1]==r:

rub_texts.append(text_rubrics.loc[l][0])

if mode == 'random':

rub_texts = [rub_texts[l] for l in lst] # делаем подвыборку в н текстов

if mode == 'first':

rub_texts = rub_texts[:n] # делаем подвыборку в н текстов

text_for_potential.extend(rub_texts)

return text_for_potential

def making_frame(window=5, base = ['yarn','model','asis'][0], n=3, t=5,use_threshold=False):

# алогритм классификации слова как сложного/простого

aver_df = pd.DataFrame(columns=['исходное','индекс','контекст','замена','сложность', 'близость', 'вероятность',

'контекстуальность', 'словарность'])

for text in make_sample(t, mode='first'):

#print(text)

tokens = text_structuring(text, complexity_type, global_threshold, use_min)

complex_words, actually_complex,complex_easier = selecting_complex(tokens, base, threshold = global_threshold, use_min = False, use_threshold=use_threshold)

indexes = {}

for token in complex_easier:

new_line = [0]*9 #будущая часть датафрейма (сперва 3 неизменнных для слова)



new_line[0] = token.lexem # для таблички - исходное слово

token.make_window(complex_words, window = window) # для подсчетов

context_text = ' '.join([c.text.lower() for c in token.context]) # для таблички - контекст 2

new_line[2] = context_text

new_line[1] = token.place # для таблички - место исходного в контексте 1

params = [0]*6 # параметры кроме сложности - изменяемый список, на его основе - выбор замены

context_lem = [c.lexem for c in token.context] # для подсчета вероятностей нграмм

text_ngrams = [g for g in ngrams(context_lem, n)] # генерация n-грамм

#p_context = context_prob(text_ngrams, use_log=False) # вероятность контекста

p_context_log = context_prob(text_ngrams, use_log=False)

# определение, насколько слово близко с другими словами из контекста

# cos_sim возвращает 0.0, если пара слов не найдена в модели

closeness = np.mean([token.cos_sim(w) for w in token.context if w.lexem!=token.lexem])

old_score = -1000

mean_cos_sim = np.mean([s.cos_sim(token) for s in token.easier])

mean_context_sim = np.mean([np.mean([s.cos_sim(w) for w in token.context[:token.place]+[s]+token.context[token.place+1:] if w.lexem!=s.lexem]) for s in token.easier])



for sub in token.easier:

if not sub.is_complex(global_threshold, True):

params[0] = sub.lexem

params[1] = (token.complexity-sub.complexity)/token.complexity # для таблички - разница сложности

# для таблички - косинусная близость

params[2] = (sub.cos_sim(token)-mean_cos_sim)/mean_cos_sim

# контекст с новым словом

sub_context = token.context[:token.place]+[sub]+token.context[token.place+1:]

# все то же самое

params[4] = (np.mean([sub.cos_sim(w) for w in sub_context if w.lexem!=sub.lexem])-mean_context_sim)/mean_context_sim # для таблички - контексная близость

sub_context_lem = [t.lexem for t in sub_context]

sub_ngrams = [g for g in ngrams(sub_context_lem, n)]

#p_changed_context = context_prob(sub_ngrams, use_log=False)-p_context

#easier_prob.append(p_changed_context) # для таблички - контексная вероятность

p_changed_context_log = context_prob(sub_ngrams, use_log=False)

#p_changed_context = context_prob(sub_ngrams, use_log=False)

params[3] = (p_context_log-p_changed_context_log)/p_context_log # для таблички - log контексная вероятность

params[5] = 1 if sub.lexem in minimum else 0

new_score = sum([i for i in params[1:-1]])

#print(params)

if old_score < new_score and new_score>0:

old_score = new_score

new_line[3:] = params[:]

indexes[token.num] = ' /'+sub.text+'/ '

#print(new_line)

# запись в датафрейм

if new_line[3]:

aver_df.loc[len(aver_df)]=new_line

if indexes:

new_text = tokens[:]

new_text = [el.text+indexes.get(el.num,'') for el in tokens]

print(''.join(new_text))

return aver_df

Размещено на Allbest.ru