В данное работе, каждое слово из корпуса было представлено как 27 морфологических и синтаксических признаков. Т.е. слово представляло собой последовательность из нулей и единиц. Если признак слова соответствовал выделенной категории, то этой категории в ряде присваивалась единица.

Были выделены следующие категории:

· Часть речи (существительное, прилагательное, глагол, предлог, союз, другие части речи)

· Падеж (именительный, родительный, дательный, винительный, творительный, предложный)

· Род (мужской, женский, средний)

· Единственное число (да/нет)

· Заглавная буква (да/нет)

· Первое слово в предложении (да/нет)

· Последнее слово в предложении (да/нет)

· Все буквы заглавные (да/нет)

· Нахождение слова в кавычках (да/нет)

· Одушевленное (да/нет)

· Дефис (да/нет)

· Является ли числом (да/нет)

· Является ли дескриптором организации (да/нет)

· Является ли дескриптором локации (да/нет)

Для частей речи и падежей, каждый компонент рассматривался как отдельная характеристика. Соответственно, если ответ был «да» - ставился «1», «нет» - «0».

Таким образом, переменная, хранящая все слова в корпусе, стала переменной, содержащей вектора этих слов.

Векторизованные слова подавались на вход алгоритмам машинного обучения в определенной форме: для перцептрона и линейного классификатора - в виде текста, для метода условных случайных полей - в виде предложений.

После работы алгоритмов машинного обучения были получены метрики эффективности (Accuracy, Precision, Recall, F-score) и производилось их сравнение. Используя алгоритм с условными случайными полями, были найдены наиболее значимые параметры для каждой именованной сущности.

3.2 Описание работы алгоритма для векторизации слов с учетом морфологических и синтаксических признаков

На вход функции подается отдельно взятое слово из текста. С помощью библиотеки pymorphy2, из каждого слова извлекаются его морфологические признаки (часть речи, падеж, число, одушевленное/неодушевленное и тд). Получение показателей, таких как заглавная буква, начало предложения, является ли данный токен числом - осуществляется с помощью базового функционала языка Python.

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

Данная функция возвращает набор нулей и единиц, длиной 27 символов.

Моделирование синтагматических отношений происходит на этапе, когда предложение представляется набором последовательностей, каждая из которых представляет собой векторизованное представление слова.

3.3 Результаты работы программы

В работе применяются следующие алгоритмы машинного обучения:

· Перцептрон (Perceptron),

· Линейный классификатор (Linear Classifiers with SGD training),

· Условные случайные поля (Conditional Random Fields (CRFs))

Первые два алгоритма принимают на вход весь текст, представленный набором нулей и единиц, тогда как для последнего метода в качестве входных параметров подаются предложения, где каждое слово представлено в векторизованном виде.

Результаты применения каждого алгоритма представлены на следующих изображениях:

· Перцептрон (Рис. 6)



Рис. 6

· Линейный классификатор (Рис. 7)

Рис. 7

· Условные случайные поля (Рис. 8)

Рис. 8



Таблица 1. Обобщенная таблица показателей для каждого тега

	surname	name	org_name	loc_name	others	not_ne
Перцептрон	0.04	0.53	0.03	0.7	0.62	0.92
Лин. классификатор	0.25	0.58	0.34	0.74	0.55	0.96
Условные случайные поля	0.8	0.8	0.4	0.79	0.56	0.98

Как видно из результатов, наилучший показатель точности по всем трём алгоритмам был получен для определения наименования географического объекта. Это может быть связано с тем, что наименования локаций постоянны и не могут варьироваться. Хуже всего определяются фамилии - их состав не постоянен, они могут быть образованы от любой основы, и наименования организаций, которые могут быть представлены любым словом.

Лучше всего с поставленной задачей справился метод, использующий алгоритм условных случайных полей. Для каждой сущности программой были определены наиболее значимые параметры. Результаты представлены в Таблице 2.

Таблица 2

	Параметры
surname	Первая буква прописная; Существительное;
name	Предлог; Союз; Женский род; Остальные части речи; Первая буква прописная; Одушевленное/неодушевленное; Единственное/множественное число
org_name	Остальные части речи; Существительное; Глагол; Женский род
loc_name	Первая буква прописная; Существительное; Все буквы прописные
others	Одушевленное/неодушевленное; Прилагательное; Дефис; Остальные части речи; Единственное/множественное число
not_ne	Дескриптор организации; Дескриптор локации; Первым слово в предложении; Дефис; Строчная буква; Женский род; Средний род; Кавычки; Предлог

Представленные в Таблице 2 параметры говорят как о наличии указанного признака, так и о его отсутствии. Многое в данном распределении зависит от качества работы морфологического классификатора. Для данной работы была предпринята попытка использовать библиотеку spacy, которая предоставляет возможность выявлять как морфологические, так и синтаксические признаки, однако для русского языка она работала не всегда корректно и было принято решение использовать pymorphy2 в качестве морфологического анализатора, а синтаксические отношения моделировались при помощи воссоздания предложения и с учетом впереди стоящих дескрипторов.

Можно заметить, что самая большая точность определения была у класса «не сущность». Это связано с тем, что такие слова всегда более частотны, чем именованные сущности. Также, стоит обратить внимание на то, что значимых признаков для их определения используется больше, чем для других тегов.

Наименования организаций размечаются хуже остальных, так как это слово алгоритм путает с «не сущностью». Набор значимых параметров для данного класс не включает в себя наличие заглавное буквы. Учитывается лишь часть речи. Однако, известно, что любая часть речи может стать эргонимом. Отсюда могут вытекать последующие ошибки.

Такие сущности, как имя и фамилия определяются одинаково точно. Набор значимых параметров для определения фамилий не велик, однако, здесь, более значимую роль могут играть синтаксические связи, например близость к имени. Для имени набор морфологических параметров более широкий, и имена менее подвержены варьированию, чем фамилии.

Алгоритм, работающий на условных случайных полях, работает лучше, чем перцептрон и линейная классификация, т.к. на вход ему подается не векторизованный текст, а набор предложений. В каждом предложении каждое слово представляет собой переменную типа «словарь», где в качестве ключей используются найденные признаки, а значения - это, соответственно, наличие или отсутствие признака. Это позволяет сделать вывод о том, что моделирование синтаксического уровня языковой системы влияет на качество работы алгоритма для решения поставленной задачи.



Заключение

В данной работе рассматривалась задача извлечения структурированной информации из текста, которая является частью процесса обработки естественного языка. Исследования в данном направлении в последнее время набирает большую популярность. Распознавание именованных сущностей может в значительной мере облегчить жизнь людей, сделать поиск нужной информации в тексте более быстрым и качественным. Областью применения данного исследования может быть не только лингвистика, но также социология, экономика, медицина и др.

Ключевым аспектом данной работы было моделирование слов на различных языковых уровнях. Была предпринята попытка представить слово, согласно его морфологическим и синтаксическим показателям, при этом, не беря во внимание семантический аспект. Современные системы, которые преобразуют слово в вектор для дальнейшего применения в алгоритме, моделируют преимущественно семантическую составляющую слова и дают высокие показатели точности определения на большом объеме обучающей выборки. Однако, в результате работы было выявлено, что моделирование морфологических и синтаксических уровней языковой системы, а также правильно подобный алгоритм, эффективно решают задачу распознавания именованных сущностей.

В данной работе, наилучшим алгоритмом был выявлен метод, использующий условные случайные поля и сущности name, surname, loc_name, org_name, others определялись соответственно с точностями 80%, 80%, 79%, 40%, 56%. Для того, чтобы улучшить показатели точности, нужно расширить набор извлекаемых признаков, например разбиением слова на значимые части (характерные суффиксы для фамилий, приставочно-суффиксальный способ образования наименований географических объектов), добавлением синтаксических характеристик слова, как члена предложения, а также увеличением объема корпуса.

Список литературы

1. Антонова А.Ю., Соловьев А.Н. Использование метода условных случайных полей для обработки текстов на русском языке, Москва

2. Богданов С.И., Евтюхин В.Б., Князев Ю.П. и др. Морфология современного русского языка: учебник для высших учебных заведений Российской Федерации, СПб: Факультет филологии и искусств СПбГУ, 2009. - 634 с.

3. Большакова Е.И., Клышинский Э.С., Ландэ Д.В. и др. Автоматическая обработка текстов на естественном языке и компьютерная лингвистика: учеб. Пособие - М.: МИЭМ, 2011 - 272 с.

4. Бондарко А.В. Теория функциональной грамматики: Введение. Аспектуальность. Временная локализованность. Таксис, Л.: Наука, 1987. - 348 с.

5. Ворон

6. Воронцов К.В. Математические методы обучения по прецедентам. Курс лекций. МФТИ. 2006

7. Гудфеллоу Я., Бенджио И., Курвилль А. Глубокое обучение / пер. с анг. А.А. Слинкина. - 2-е изд., испр. - М.: ДМК Пресс, 2018. - 652 с.

8. Камынина А.А. Современный русский язык: морфология: учеб. Пособие для студентов филол. Ф-тов гос. Ун-тов. М., 1999

9. Киселев С.Л., Ермаков А.Е., Плешко В.В., Поиск фактов в тексте естественного языка на основе сетевых описаний, Доклады международной конференции Диалог 2004.

10. Крейдлин Л.Г. Программа выделения русских индивидуализированных именных групп TagLite // Компьютерная лингвистика и интеллектуальные технологии: труды Международной конференции Диалог'2006. - Звенигород 2006, с. 292-297.

11. Марков, А.А. Избранные труды по теории непрерывных дробей и теории функций наименее уклоняющихся от нуля / А.А. Марков // под ред. Н.И. Ахизер. - М. : Гостехиздат, 1948. - 416 с.

12. Николаев И.С., Митренина О.В., Ландо Т.М (ред.) Прикладная и компьютерная лингвистика -М.: Ленанд, 2016 -316 с.

13. Подольская Н.В. Словарь русской ономастической терминологии, 2-е изд., перераб. и доп. -М.: 1988.- 192 с.

14. Розенблатт Ф. Принципы нейродинамики: Перцептроны и теория механизмов мозга. - М,: Мир, 1965. - 480 с.

15. Чачхиани Т.И., Серова М.Г. Алгоритм перцептрона: практикум. - Нижний Новгород: Нижегородский госуниверситет, 2015. - 25 с.

16. Ярцева В.Н. Лингвистический энциклопедический словарь, - 2-е изд., доп. - М. : Большая рос. энцикл., 2002. - 709 с.

17. Bishop. Ch. Pattern Recognition and Machine Learning. Springer. 2006.

18. Bottou L, Bousquet O. The Tradeoffs of Large Scale Learning. Advances in Neural Information Processing Systems, 2008, P 161-168 (стохастический градиентный спуск)

19. Bottou L, Online Algorithms and Stochastic Approximation, Cambridge University Press (стохастический гр спуск)

20. Bunescu R. and Paska M. Using Encyclopedic Knowledge for Named Entity Disambiguation // Proceedings of of the 11th Conference of the European Chapter of the Association for Computational Linguistics (EACL-2006). -Trento, Italy: Association for Computational Linguistics, 2006, P. 9-16.

21. Califf M.E. and Mooney R.J. Relational learning of pattern-match rules for information extraction. In Proceedings of the 16th National Conference on Artificial Intelligence and the 11th Innovative Applications of the Artificial Intelligence Conference, 1999, P. 328-334

22. Guo-Xun Yuan; Chia_hua Ho; Chih-Jen Lin Recent Advances of Large-Scale Linear Classification, 2012

23. Hastie T., Tibshirani R, Friedman J. The Elements of Statistical Learning (2nd edition). Springer, 2009.

24. Hogenboom F., Frasincar F., Kaymak U. An Overview of Approaches to Extract Information from Natural Language Corpora. DIR 2010 January 25, 2010, Nijmegen, the Netherlands

25. Klinger R., Tomanek K. Classical Probabilistic Models and Conditional Random Fields. Algorithm Engineering Report TR07-2-013. Department of Computer Science. Dortmund University of Technology. December 2007.

26. Lafferty John, McCallum Andrew, Pereira Fernando C.N. Conditional Random Fields: Probabilistic Models for Segmenting and Labeling Sequence Data // Proceedings of the 18th International Conference on Machine Learning 2001. -- 2001. -- June. -- P. 282-289.

27. Michelson M. and Knoblock C.A. Creating Relational Data from Unstructured and Ungrammatical Data Sources. In Journal of African Intelligence Research 31 (2008), 2008, P. 543-590.

28. Murphy K. Machine Learning: A Probabilistic Perspective. MIT Press, 2012.

29. Sutton C., McCallum A. Introduction to Conditional Random Fields for Relational Learning. MIT Press. 2006.

30. Willi Richert, Luis Pedro Coelho. Building Machine Learning Systems with Python. Packt Publishing, 2013.



Приложение

import os

import glob

import pymorphy2

import re

morph = pymorphy2.MorphAnalyzer()

os.chdir("C:\Python\Diploma\corpora data")

docs = glob.glob('*.txt')

doc_lst = [] # создаем список для хранения имен текстов

for doc in docs:

name = doc[:-4]

doc_lst.append(name)

doc_lst_learn = []

doc_lst_test = []

for i in range(12, 122):

doc_lst_learn.append(doc_lst[i]) #список документов обучающей выборки

print(len(doc_lst_learn))

for q in range(12):

doc_lst_test.append(doc_lst[q]) #список документов тестовой выборки

words = ['start_token']

tags = ['start_state']

#Формирование размеченного корпуса для обучающей и тестовой выборки

def corp_create(doc_lst):

dict_tok = {}

corpora = str()

app_tokens = ['loc_name', 'org_name', 'name', 'surname', 'org_descr', 'loc_descr']

not_match = ['nickname', 'job', 'patronymic']

for doc_name in doc_lst:

name_tok_tpl = doc_name + '.tokens'

tokens_text = open(name_tok_tpl, encoding='utf-8').read()

tokens_text_spl = tokens_text.split('\n')

for t in tokens_text_spl:

t_lst = t.split()

if t_lst:

word = t_lst[-1]

ids = t_lst[0]

dict_tok[ids] = [word]

name_sp_tpl = doc_name + '.spans'

spans_text = open(name_sp_tpl, encoding='utf-8').read()

spans_text_spl = spans_text.split('\n')

for s in spans_text_spl:

s_lst = s.split()

if s_lst:

word = s_lst[-1]

ids = s_lst[-2]

tok = s_lst[1]

if tok in app_tokens:

if (ids in dict_tok) and dict_tok[ids][0] == word:

dict_tok[ids].append(tok)

if tok in not_match:

if (ids in dict_tok) and dict_tok[ids][0] == word:

dict_tok[ids].append('others')

for k in dict_tok:

if len(dict_tok[k]) != 2:

dict_tok[k].append('not_ne')

for k in dict_tok:

words.append(dict_tok[k][0])

tags.append(dict_tok[k][1])

corpora += dict_tok[k][0] + '_' + dict_tok[k][1] + ' '

return corpora

learn_corp = corp_create(doc_lst_learn)

words.append("end_token")

tags.append("end_state")

os.chdir("../")

open('corpora.txt', 'w', encoding='utf-8').write(learn_corp)

test = set(tags)

import pymorphy2

import re

morph = pymorphy2.MorphAnalyzer()

newWordList = []

newTagList = []

for i, word in enumerate(words):

if word in [".", "!", "?", "«", "»"]:

if word in [".", "!", "?"] and words[i+1] not in ["«", "»"]:

newWordList.append("end_token")

newTagList.append("end_state")

newWordList.append("start_token")

newTagList.append("start_state")

if word in ["«", "»"]:

newWordList.append(word)

newTagList.append(tags[i])

else:

wordParse = morph.parse(word)[0]

if "PNCT" not in wordParse.tag:

newWordList.append(word)

newTagList.append(tags[i])

words = newWordList

tags = newTagList

print(words[:20])

category = []

for tag in tags:

if tag == "loc_name":

category.append(1)

if tag == "org_name":

category.append(2)

if tag == "name":

category.append(3)

if tag == "surname":

category.append(4)

if tag == "others":

category.append(5)

if tag == "start_state":

category.append(6)

if tag == "end_state":

category.append(7)

if tag == "not_ne":

category.append(8)

#Функция векторизации слов

def word_vectorizer(word, idd):

wordVector = []

for i in range(27):

wordVector.append(0)

if word in ["start_token", "end_token", "«", "»"]:

if word == "start_token":

bracketCounter[word] += 1

if bracketCounter[word] == 2:

bracketCounter[word] = 1

if word in ["«", "»"]:

bracketCounter['bracket'] += 1

if bracketCounter['bracket'] == 3:

bracketCounter['bracket'] = 1

return wordVector

wordParse = morph.parse(word)[0]

caracList = wordParse.tag

partOfSpeech = caracList.POS

if partOfSpeech in ["NOUN", "ADJF", "ADJS", "VERB", "PREP", "CONJ"]:

if partOfSpeech == 'NOUN':

wordVector[0] = 1

if partOfSpeech == 'ADJF' or partOfSpeech == 'ADJS':

wordVector[1] = 1

if partOfSpeech == 'VERB':

wordVector[2] = 1

if partOfSpeech == 'PREP':

wordVector[3] = 1

if partOfSpeech == 'CONJ':

wordVector[4] = 1

else:

wordVector[5] = 1

if word.isupper():

wordVector[19] = 1

if word.islower():

wordVector[20] = 1

if word.isdigit():

wordVector[24] = 1

wordParse = morph.parse(word)[0]

caracList = wordParse.tag

if 'nomn' in caracList:

wordVector[6] = 1

if 'gent' in caracList:

wordVector[7] = 1

if 'datv' in caracList:

wordVector[8] = 1

if 'accs' in caracList:

wordVector[9] = 1

if 'ablt' in caracList:

wordVector[10] = 1

if 'loct' in caracList:

wordVector[11] = 1

if 'sing' in caracList:

wordVector[12] = 1

if 'masc' in caracList:

wordVector[13] = 1

if 'femn' in caracList:

wordVector[14] = 1

if 'neut' in caracList:

wordVector[15] = 1

if 'anim' in caracList:

wordVector[22] = 1

if len(word) > 1 and word[0].isupper() and word[1].islower():

wordVector[16] = 1

if bracketCounter["start_token"] == 1 and bracketCounter["bracket"] == 1:

wordVector[21] = 1

if words[idd-1] == "start_token":

wordVector[17] = 1

if words[idd+1] == "end_token":

wordVector[18] = 1

if "-" in word:

wordVector[23] = 1

if tags[idd] == 'loc_descr':

wordVector[25] = 1

tags[idd] = 'not_ne'

if tags[idd] == 'org_descr':

wordVector[26] = 1

tags[idd] = 'not_ne'

return wordVector

bracketCounter = {"start_token":0, "bracket":0}

vectorData = []

for i, word in enumerate(words):

synWordVector = []

synWordVector = word_vectorizer(word, i)

vectorData.append(synWordVector)

expVectorData = []

for i, token in enumerate(words):

exampleVector = []

if token not in ['start_token', 'end_token']:

exampleVector.append(vectorData[i-1])

exampleVector.append(vectorData[i])

exampleVector.append(vectorData[i+1])

expVectorData.append(exampleVector)

else:

for k in range (3):

exampleVector.append(vectorData[i])

expVectorData.append(exampleVector)

#Векторизуем предложения

state_dict = {'start':0, 'end':0}

def sent2features(words):

sentVector = []

wordToSent = []

for i, token in enumerate(words):

if token == 'start_token':

state_dict['start'] += 1

if state_dict['start'] == 2:

state_dict['start'] = 1

if token == 'end_token':

state_dict['end'] += 1

if state_dict['start'] == 1 and state_dict['end'] == 0 and token != 'start_token':

sentVector.append(expVectorData[i])

if state_dict['end'] == 1:

state_dict['end'] = 0

wordToSent.append(sentVector)

sentVector = []

return wordToSent

def sent2dictFeatures(words):

sentVector = []

wordToSent = []

for i, token in enumerate(words):

if token == 'start_token':

state_dict['start'] += 1

if state_dict['start'] == 2:

state_dict['start'] = 1

if token == 'end_token':

state_dict['end'] += 1

if state_dict['start'] == 1 and state_dict['end'] == 0 and token != 'start_token':

wordVector = vectorData[i]

features = { str(k) : wordVector[k] for k in range(0, len(wordVector) ) }

sentVector.append(features)

if state_dict['end'] == 1:

state_dict['end'] = 0

wordToSent.append(sentVector)

sentVector = []

return wordToSent

sentDictFeatures = sent2dictFeatures(words)

print(sentDictFeatures[:2])

state_dict = {'start':0, 'end':0}

def sent2tags(tags):

sentVector = []

tagToSent = []

for tag in tags:

if tag == 'start_state':

state_dict['start'] += 1

#print('предложение ' , i+1, ' началось')

if state_dict['start'] == 2:

state_dict['start'] = 1

if tag == 'end_state':

state_dict['end'] += 1

if state_dict['start'] == 1 and state_dict['end'] == 0 and tag != 'start_state':

sentVector.append(tag)

if state_dict['end'] == 1:

state_dict['end'] = 0

tagToSent.append(sentVector)

#print('добавляем вектор предложения в массив векторов для всего текста')

sentVector = []

return tagToSent

sentTagVectors = sent2tags(tags)

test = set(tags)

import pandas as pd

import numpy as np

from sklearn.feature_extraction import DictVectorizer

from sklearn.feature_extraction.text import HashingVectorizer

from sklearn.linear_model import Perceptron

from sklearn.model_selection import train_test_split

from sklearn.linear_model import SGDClassifier

from sklearn.linear_model import PassiveAggressiveClassifier

from sklearn.naive_bayes import MultinomialNB

from sklearn.metrics import classification_report

X = np.array(vectorData)

y = np.array(tags)



classes = np.unique(y)

classes = classes.tolist()

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.33, random_state=0)

X_train.shape, y_train.shape

#Перцептрон

per = Perceptron(verbose=20, n_jobs=-1, max_iter=20)

per.partial_fit(X_train, y_train, classes)

new_classes = classes.copy()

new_classes.remove('end_state')

new_classes.remove('start_state')

new_classes

print(classification_report(y_pred=per.predict(X_test), y_true=y_test, labels=new_classes))

per_full = Perceptron(verbose=20, n_jobs=-1, max_iter=10, n_iter_no_change = 10)

per_full.fit(X_train, y_train)

print(classification_report(y_pred=per.predict(X_test), y_true=y_test, labels=new_classes))

#Linear classifiers with SGD training

sgd = SGDClassifier(max_iter=1000 , n_iter_no_change = 1000)

sgd.partial_fit(X_train, y_train, classes)

print(classification_report(y_pred=sgd.predict(X_test), y_true=y_test, labels=new_classes))



sgd = SGDClassifier()

sgd.fit(X_train, y_train)

print(classification_report(y_pred=sgd.predict(X_test), y_true=y_test, labels=new_classes))

#Conditional Random Fields (CRFs)

X_crf = sentDictFeatures

y_crf = sentTagVectors

X_crf_train, X_crf_test, y_crf_train, y_crf_test = train_test_split(X_crf, y_crf, test_size=0.33, random_state=0)

import sklearn_crfsuite

from sklearn_crfsuite import scorers

from sklearn_crfsuite import metrics

from collections import Counter

crf = sklearn_crfsuite.CRF(

algorithm='lbfgs',

c1=0.1,

c2=0.1,

max_iterations=100,

all_possible_transitions=True

)

crf.fit(X_crf_train, y_crf_train)

y_crf_pred = crf.predict(X_crf_test)

print(metrics.flat_classification_report(y_crf_test, y_crf_pred, labels = new_classes))



metrics.flat_f1_score(y_crf_test, y_crf_pred,

average='weighted', labels=new_classes)

import scipy.stats

from sklearn.metrics import make_scorer

from sklearn.model_selection import cross_val_score

from sklearn.model_selection import RandomizedSearchCV

crf = sklearn_crfsuite.CRF(

algorithm='lbfgs',

max_iterations=100,

all_possible_transitions=True

)

params_space = {

'c1': scipy.stats.expon(scale=0.5),

'c2': scipy.stats.expon(scale=0.05),

}

# use the same metric for evaluation

f1_scorer = make_scorer(metrics.flat_f1_score,

average='weighted', labels=new_classes)

# search

rs = RandomizedSearchCV(crf, params_space,

cv=3,

verbose=1,

n_jobs=-1,

n_iter=50,

scoring=f1_scorer)

rs.fit(X_crf_train, y_crf_train)



# crf = rs.best_estimator_

print('best params:', rs.best_params_)

print('best CV score:', rs.best_score_)

print('model size: {:0.2f}M'.format(rs.best_estimator_.size_ / 1000000))

crf = rs.best_estimator_

y_pred = crf.predict(X_crf_test)

print(metrics.flat_classification_report(

y_crf_test, y_crf_pred, labels=new_classes

))

#Для определения значимых параметров

from collections import Counter

def print_transitions(trans_features):

for (label_from, label_to), weight in trans_features:

print("%-6s -> %-7s %0.6f" % (label_from, label_to, weight))

print("Top likely transitions:")

print_transitions(Counter(crf.transition_features_).most_common(20))

print("\nTop unlikely transitions:")

print_transitions(Counter(crf.transition_features_).most_common()[-20:])

def print_state_features(state_features):

for (attr, label), weight in state_features:

print("%0.6f %-8s %s" % (weight, label, attr))

print("Top positive:")

print_state_features(Counter(crf.state_features_).most_common(30))

print("\nTop negative:")

print_state_features(Counter(crf.state_features_).most_common()[-30:])

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

...