Эти примеры взяты из корпусов и из источников в Интернете. Любые мнения в примерах не отражают мнение редакторов Cambridge Dictionary, Cambridge University Press или его лицензиаров.

# Тегер для словаря. # Мы предполагаем, что словарный запас для языка доступен. # Предположим, что у нас реализована небольшая приключенческая игра. # Мы могли бы взять все слова, использованные в описании # эту игру и поместите их в словарь. Это лексикон. # Это часть системы синтаксического анализа, в которой мы хотим иметь возможность # чтобы получить ввод пользователя от пользователя, который не строго следует # предопределенных ответов, но кто может использовать язык более свободно. lexicon = {«direction»: [«север», «юг», «восток», «запад», «вниз», «вверх», «влево», «вправо», «назад»], «глагол»: [«ходить», «останавливаться», «убивать», «есть», «бросать», «брать», «открывать», «давать»], «stop»: [«the», «in», «of», «from», «at», «it», «a», «to»], «существительное»: [«я», «дверь», «медведь», «принцесса», «шкаф», «меч», «алмаз», «ручка»]} # По желанию, мы могли бы добавить некоторые другие общие формы для глаголов: s_forms = [] слово в лексиконе [«глагол»]: s_form = слово + «s» s_forms. добавить (s_form) lexicon [«глагол»] = lexicon [«глагол»] + s_forms # Кроме того, лексика может допускать любое количество цифр 0,1, …, 9, # длиной не более 10, представляющих числа. # Они не будут определяться перечислением в словаре, но мы # определите их в определении. номер def (n): typ_str = isinstance (n, str) # мы предполагаем, что номер действительно указан в текстовой строке. если typ_str и len (n) «9»: is_number = Ложь вернуть is_number еще: вернуть ложь # Теперь мы можем определить теггер.На основе лексики и определения # чисел, он может пометить предложение. # Обычно для заданных текстовых строк он должен возвращать список пар (тег, слово). # «идти на север» -> [(‘глагол’, ‘идти’), (‘направление’, ‘север’)] # «убить принцессу» -> [(‘глагол’, ‘убить’), (‘стоп’, ‘the’), (‘существительное’, ‘принцесса’)] # «съесть медведя» -> [(‘глагол’, ‘есть’), (‘стоп’, ‘the’), (‘существительное’, ‘медведь’)] # «открой дверь и удари медведя по носу» # -> [(‘глагол’, ‘открыть’), (‘стоп’, ‘the’), (‘существительное’, ‘дверь’), (‘ошибка’, ‘и’), (‘ошибка’, ‘хлопать’), # (‘стоп’, ‘the’), (‘существительное’, ‘медведь’), (‘стоп’, ‘in’), (‘стоп’, ‘the’), (‘ошибка’, ‘нос’) ] sent = raw_input («Внесите свой вклад>») sent_list = отправлено. нижний (). split () # Преобразуем текстовую строку в список слов. # Примечание: мы использовали строчные буквы для ввода заглавных букв. тег def (sentlst): print «Tagging» taglst = [] для слова в sentlst: если слово в лексиконе [«направление»]: taglst.append ((«направление», слово)) слово elif в лексиконе [«глагол»]: taglst.append ((«глагол», слово)) слово elif в лексиконе [«стоп»]: taglst.append ((«стоп», слово)) слово elif в лексиконе [«существительное»]: taglst.append ((«существительное», слово)) elif число (слово): taglst.append ((«число», слово)) else: taglst.append ((«ошибка», слово)) печать тегов вернуть taglst # «ошибка» используется для всех тех слов, которые не встречаются в лексиконе. # Мы не знаем, что это за слова. # Далее мы разрабатываем очень простой парсер. # Парсер попытается обнаружить текстовые структуры вида: # Subject Verb Object # внутри предложения, вводимого пользователем. # Для «объекта» мы также разрешим направления и числа.# Если пользователь вводит что-то вроде: # «открытая дверь» # тогда система должна предположить, что тема пропущена, но # что предполагаемый объект действительно был «игроком». # С помощью этого парсера мы упрощаем ввод пользователя во ввод, который # приключенческая игра может реагировать на. # Определение верхнего уровня для синтаксического анализа: # пометить введенное предложение # получить тему # получить глагол # получить объект def parse (sent_lst): tag_lst = тег (отправлено_lst) clean_lst = чистый (tag_lst) (тема, new_lst) = parse_subj (clean_lst) (глагол, new_lst) = parse_verb (new_lst) объект = parse_obj (новый_ст) если субъект == Нет или глагол == Нет или объект == Нет: print «Я не могу разобрать этот ввод.» return None else: вернуть предложение (подлежащее, глагол, объект) # Сначала мы помечаем список слов. # # Потом убираем: слова с тегами, не имеющими отношения к # цель парсера убрана. Он касается # теги остановки и ошибки. # Наши функции parse_subj, parse_verb и parse_obj будут # не сканировать все время очищенный tag_list, потому что это # было бы неэффективно. Они удалят начальные части очищенного # tag_list, чтобы более поздние функции синтаксического анализа больше не работали # с этими частями. # Сначала очистка: удалите все лишние слова: «стоп» # слова и слова «ошибка». # Наивная, но _ неправильная_ реализация: # def clean (tag_lst): # для i в диапазоне (len (tag_lst)): # (тег, слово) = tag_lst [i] # if tag == «stop» или tag == «error»: # del (tag_lst [i]) # return tag_lst # Еще одна наивная, но столь же _ неправильная_ реализация: #def clean (tag_lst): # для (тега, слова) в tag_lst: # if tag == «stop» или tag == «error»: # tag_lst.удалить ((тег, слово)) # print tag_lst # return tag_lst def clean (tag_lst): печать «Очистка» clean_lst = [] для (тег, слово) в tag_lst: если нет (тег == «стоп»), а не (тег == «ошибка»): clean_lst.append ((тег, слово)) распечатать clean_lst вернуть clean_lst # Найти подлежащее означает: найти существительное, которое стоит первым в # предложение, или, если глагол идет первым, подлежащее — «игрок». def parse_subj (tag_lst): print «Разбор по теме» если tag_lst == []: return (Нет, []) (тег, слово) = tag_lst [0] если tag == «глагол»: return («игрок», tag_lst) elif tag == «существительное»: del (tag_lst [0]) возврат (слово, tag_lst) еще: return (Нет, []) def parse_verb (tag_lst): print «Разбор на глагол» если tag_lst == []: return (Нет, []) (тег, слово) = tag_lst [0] если tag == «глагол»: del (tag_lst [0]) возврат (слово, tag_lst) еще: return (Нет, []) def parse_obj (tag_lst): print «Разбор объекта» если tag_lst == []: return None (тег, слово) = tag_lst [0] if tag == «существительное» или tag == «направление» или tag == «число»: ответное слово еще: return None def предложение (subj, глагол, obj): print «Результат анализа:» напечатать subj, глагол, obj вернуть subj, глагол, obj синтаксический анализ (список отправленных) #Примеры: print «Разбор предложения» Прекрасная принцесса идет на север «» parse («Прекрасная принцесса идет на север». нижний (). split ()) print «Разбирая предложение» Я уронил 2345 золотых монет «» parse («Я бросил 2345 золотых монет» .lower (). split ()) print «Разбираем фразу» убить бурого медведя «» parse («убить бурого медведя» .split ())

python 3.x — Создание деревьев синтаксического анализа в NLTK с использованием предложения с тегами

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

Большинство людей видят эту ошибку при попытке использовать StanfordParser в NLTK

  >>> из nltk.parse import stanford
>>> sp = stanford.StanfordParser ()
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
  Файл "/home/user/anaconda3/lib/python3.5/site-packages/nltk/parse/stanford.py", строка 51, в __init__
    key = лямбда имя_модели: re.match (self._JAR, имя_модели)
  Файл "/ home / user / anaconda3 / lib / python3. 5 / site-packages / nltk / internals.py ", строка 714, в find_jar_iter
    поднять LookupError ('\ n \ n% s \ n% s \ n% s'% (div, msg, div))
LookupError:

================================================== =========================
  NLTK не смог найти stanford-parser \ .jar! Установите CLASSPATH
  переменная окружения.

  Для получения дополнительной информации о stanford-parser \ .jar см .:
    
================================================== =========================
  

Чтобы исправить это, загрузите Stanford Parser в каталог и извлеките его содержимое.Давайте использовать пример каталога в системе * nix / usr / local / lib / stanfordparser . Файл stanford-parser.jar должен находиться там вместе с другими файлами.

Когда все файлы будут там, установите переменные среды для расположения анализатора и моделей.

  >>> импорт ОС
>>> os.environ ['STANFORD_PARSER'] = '/ usr / local / lib / stanfordparser'
>>> os. environ ['STANFORD_MODELS'] = '/ usr / local / lib / stanfordparser'
  

Теперь вы можете использовать синтаксический анализатор для экспорта возможных синтаксических анализов для имеющегося у вас предложения, например:

  >>> sp = stanford.СтэнфордПарсер ()
>>> sp.parse ("это предложение" .split ())
<объект list_iterator в 0x7f53b93a2dd8>
>>> tree = [дерево вместо дерева в sp.parse ("это предложение" .split ())]
>>> деревья [0] # пример проанализированного предложения
Дерево ('КОРЕНЬ', [Дерево ('S', [Дерево ('NP', [Дерево ('DT', ['this'])]), Дерево ('VP', [Дерево ('VBZ', [ 'is']), Tree ('NP', [Tree ('DT', ['a']), Tree ('NN', ['предложение'])])])])])
  

Возвращается объект итератора , поскольку для данного предложения может быть более одного синтаксического анализатора.

Python 3 Примечания: разделение и объединение

На этой странице: . split (), .join () и list (). Разделение предложения на слова: .split () Ниже Мэри представляет собой единую струну. Несмотря на то, что это предложение, слова не представлены в виде скрытых единиц. Для этого вам понадобится другой тип данных: список строк, где каждая строка соответствует слову. .split () - это метод, который нужно использовать: >>> mary = 'У Мэри был ягненок' >>> мэри.расколоть() ['У Мэри был маленький ягненок'] .split () разбивает mary на whitespce, и возвращаемый результат представляет собой список слов в mary. Этот список содержит 5 элементов, как демонстрирует функция len (). len () для mary, напротив, возвращает количество символов в строке (включая пробелы). >>> mwords = mary.split () >>> mwords ['У Мэри был маленький ягненок'] >>> len (mwords) 5 >>> len (мэри) 22 Пробельные символы включают в себя, среди прочего, пробел '', символ новой строки '\ n' и табуляцию '\ t'. .split () разделяет любую комбинированную последовательность этих символов: >>> chom = 'бесцветный зеленый \ n \ tideas \ n' >>> печать (чом) бесцветный зеленый идеи >>> chom.split () ["бесцветный", "зеленый", "идеи"] Разделение на определенную подстроку Предоставляя необязательный параметр,.split ('x') может использоваться для разделения строки на определенную подстроку 'x'. Без указания 'x' .split () просто разбивается на все пробелы, как показано выше. >>> mary = 'У Мэри был ягненок' >>> mary.split ('а') ['M', 'ry h', 'd', 'little l', 'mb'] >>> hi = 'Привет, мама, \ nПривет, папа'. >>> печать (привет) Привет мама, Привет папа. >>> привет.расколоть() [«Привет», «мама», «Привет», «отец».] >>> привет.split ('\ n') [«Привет, мама», «Привет, отец». ] Строка в списке символов: list () Но что, если вы хотите разбить строку на список символов? В Python символы - это просто строки длиной 1. Функция list () превращает строку в список отдельных букв: >>> список ('привет мир') ['Привет мир'] В более общем смысле list () - это встроенная функция, которая превращает объект данных Python в список.Когда указан строковый тип, возвращается список символов в нем. Когда указываются другие типы данных, особенности меняются, но возвращаемый тип всегда является списком. См. Подробности в этом руководстве. Присоединение к списку строк: .join () Если у вас есть список слов, как собрать их в одну строку? .join () - это метод, который нужно использовать. Вызывается в строке-разделителе 'x', 'x'.join (y) объединяет каждый элемент в списке y, разделенный' x '. Ниже слова в mwords объединяются обратно в строку предложения с пробелом между ними: >>> mwords ['У Мэри был маленький ягненок'] >>> ''.присоединиться (mwords) 'У Мэри был маленький ягненок' Присоединение может быть выполнено на любой строке-разделителе. Ниже используются '-' и символ табуляции '\ t'. >>> '-'. join (mwords) 'У Мэри был маленький ягненок' >>> '\ t'.join (mwords) 'Мэри \ тхад \ та \ тлиттл \ тэмб' >>> print ('\ t'.join (mwords)) У Мэри был маленький ягненок Метод также можно вызвать для пустой строки '' в качестве разделителя.Эффект состоит в том, что элементы в списке соединены между собой, между которыми ничего нет. Ниже список символов объединен в исходную строку: >>> привет = 'привет мир' >>> hichars = список (привет) >>> hichars ['Привет мир'] >>> '' . join (hichars) 'Привет мир'

Лингвистические особенности · Документация по использованию spaCy

Разумная обработка исходного текста затруднена: большинство слов встречаются редко, и это обычно для слов, которые выглядят совершенно по-разному, означает почти одно и то же.Одни и те же слова в разном порядке могут означать совсем другое. Даже разделение текста на полезные словесные единицы может быть трудным во многих случаях. языков. Хотя некоторые проблемы можно решить, начав только с исходных символов, обычно лучше использовать лингвистические знания, чтобы добавить полезные Информация. Именно для этого и предназначен spaCy: вы вводите необработанный текст, и получите объект Doc , который поставляется с различными аннотации.

После токенизации spaCy может анализировать и тег для данного Doc .Это где поступает обученный конвейер и его статистические модели, которые позволяют spaCy делает прогнозы, из которых тег или метка наиболее вероятно применимы в данном контексте. Обученный компонент включает двоичные данные, которые создаются путем отображения системы. достаточно примеров для того, чтобы делать прогнозы, которые обобщаются по всему языку - например, слово, следующее за «the» в английском языке, скорее всего, является существительным.

Лингвистические аннотации доступны как Токен атрибутов. Как и многие библиотеки НЛП, spaCy кодирует все строки в хеш-значения , чтобы уменьшить использование памяти и улучшить эффективность.Итак, чтобы получить удобочитаемое строковое представление атрибута, мы необходимо добавить подчеркивание _ к его имени:

  import spacy

nlp = spacy.load ("en_core_web_sm")
doc = nlp («Apple собирается купить британский стартап за 1 миллиард долларов»)

для токена в документе:
    print (token.text, token.lemma_, token.pos_, token.tag_, token.dep_,
            token.shape_, token.is_alpha, token.is_stop)
  

• Текст: Исходный текст слова.
• Лемма: Основная форма слова.
• POS: Простой UPOS тег части речи.
• Тег: Подробный тег части речи.
• Dep: Синтаксическая зависимость, то есть отношение между токенами.
• Форма: Форма слова - заглавные буквы, знаки препинания, цифры.
• - это альфа: Является ли токен альфа-символом?
• is stop: Является ли токен частью стоп-листа, т. Е. Наиболее частыми словами язык?

Текст	Лемма	POS	Тег	Dep	Форма	альфа	стоп
Apple	Apple			Xxxxx	True	False
is	be	AUX	VBZ	aux	xx	True
смотря	look	VERB	VBG	ROOT	xxxx	True	False
при	ADP	IN	Prep	xx	True	True
покупка	покупка	VERB	VBG	pcomp	xxx	Верно	Ложно
U. K.	u.k.	PROPN	NNP	составной	X.X.	Ложь	Ложь
запуск	запуск	NOUN	NN	dobj	xxxx	True	False
для	для	ADP	IN	Prep	xxx	True	True
$	$	SYM	$	Quantmod	$	Ложь	Ложь
1	1	NUM	CD	составной	d	Неверно	Ложь
миллиардов	миллиардов	NUM	CD	pobj	xxxx	Истинно	Ложно

Совет: теги и ярлыки

Большинство тегов и ярлыков выглядят довольно абстрактно, и они различаются между языков. spacy.explain покажет вам краткое описание — например, spacy.explain ("VBZ") возвращает «глагол, 3-е лицо единственного числа настоящее».

Используя встроенный визуализатор дисплея spaCy, вот что наше примерное предложение и его зависимости выглядят следующим образом:

scheme Схема тега части речи

Для списка назначенных мелкозернистых и крупнозернистых тегов части речи по моделям spaCy на разных языках, см. задокументированные схемы этикеток в каталоге моделей.

Флективная морфология — это процесс, с помощью которого корневая форма слова изменен путем добавления префиксов или суффиксов, определяющих его грамматическую функцию но не меняйте его часть речи. Мы говорим, что лемма (корневая форма) является перегиб (модифицированный / комбинированный) с одним или несколькими морфологическими признаками от до создать форму поверхности. Вот несколько примеров:

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

📝 Что стоит попробовать

1. Измените «Я» на «Она». Вы должны увидеть, что морфологические признаки меняются и укажите, что это местоимение от третьего лица.
2. Осмотрите жетон . Морф на предмет других жетонов.

  импорт просторный

nlp = spacy.load ("en_core_web_sm")
print ("Конвейер:", nlp.pipe_names)
doc = nlp ("Я читал газету.")
токен = документ [0]
печать (токен.превращаться)
print (token.morph.get ("PronType"))
  

Статистическая морфология v3.0 Модель потребностей

Компонент spaCy статистический Морфологизатор назначает морфологические особенности и грубые теги части речи как Token.morph и Token.pos .

  импорт просторный

nlp = spacy.load ("de_core_news_sm")
doc = nlp ("Wo bist du?")
печать (документ [2] .morph)
печать (документ [2] .pos_)
  

Морфология на основе правил

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

1. Тегер части речи назначает каждому токену детализированную часть речи тег . В API эти теги известны как Token.tag . Они выражают часть речи (например, глагол) и некоторое количество морфологической информации, например что глагол имеет прошедшее время (например, VBD для глагола прошедшего времени в Penn Treebank).
2. Для слов, крупнозернистый POS которых не установлен предыдущим процессом, таблица сопоставления отображает мелкозернистые теги в крупнозернистые POS-теги и морфологические особенности.

  импорт просторный

nlp = spacy.load ("en_core_web_sm")
doc = nlp ("Где ты?")
печать (документ [2] .morph)
печать (документ [2] .pos_)
  

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

  импорт просторный


nlp = spacy. load ("en_core_web_sm")
lemmatizer = nlp.get_pipe ("лемматизатор")
печать (лемматизатор.Режим)

doc = nlp ("Я читал газету.")
print ([token.lemma_ для токена в документе])

  

Изменено в версии 3.0

В отличие от spaCy v2, модели spaCy v3 , а не предоставляют леммы по умолчанию или переключение автоматически между поиском и леммами на основе правил в зависимости от того, находится в стадии разработки. Чтобы иметь леммы в Doc , конвейер должен включать Лемматизатор компонент. Компонент лемматизатора настроен на использование одного режима, такого как «поиск» или «правило» на инициализация. "правило" Режим требует, чтобы Token.pos был установлен предыдущим составная часть.

Данные для лемматизаторов spaCy распространяются в пакете данные пространственного поиска . В при условии, что обученные конвейеры уже включают все необходимые таблицы, но если вы создаете новые конвейеры, вы, вероятно, захотите установить spacy-lookups-data для предоставления данных при инициализации лемматизатора.

Поисковый лемматизатор

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

 
импортный простор

nlp = spacy.blank ("sv")
nlp.add_pipe ("лемматизатор", config = {"режим": "поиск"})
  

Лемматизатор на основе правил

При обучении конвейеров, которые включают компонент, который назначает часть речи теги (морфологизатор или теггер с отображением POS), лемматизатор на основе правил может быть добавлен с помощью таблиц правил из данные пространственного поиска :

 
импортный простор

nlp = простор.пустой ("де")

nlp.add_pipe ("морфологизатор")

nlp.add_pipe ("лемматизатор", config = {"режим": "правило"})
  

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

spaCy имеет быстрый и точный синтаксический анализатор зависимостей, а также богатый набор функций. API для навигации по дереву.Синтаксический анализатор также поддерживает границу предложения обнаружения и позволяет вам перебирать базовые словосочетания с существительными или «фрагменты». Ты можешь проверьте, был ли проанализирован объект Doc путем вызова doc.has_annotation ("DEP") , который проверяет, имеет ли атрибут Token.dep set возвращает логическое значение. Если результат Ложь , предложение по умолчанию итератор вызовет исключение.

📖Схема меток зависимостей

Для списка меток синтаксических зависимостей, назначенных моделями spaCy в разных языках, см. схемы этикеток, задокументированные в каталог моделей.

Отрезки существительных

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

  импорт просторный

nlp = spacy.load ("en_core_web_sm")
doc = nlp («Автономные автомобили переносят страхование ответственности на производителей»)
для куска в док.noun_chunks:
    print (chunk.text, chunk.root.text, chunk.root.dep_,
            chunk.root.head.text)
  

• Текст: Исходный текст фрагмента существительного.
• Корневой текст: Исходный текст слова, соединяющего кусок существительного с остальная часть синтаксического анализа.
• Root dep: Отношение зависимости, соединяющее корень с его головкой.
• Текст заголовка корневого токена: Текст заголовка корневого токена.

Навигация по дереву синтаксического анализа

spaCy использует термины head и child для описания слов , связанных между собой единственная дуга в дереве зависимостей.Термин dep используется для дуги метка, которая описывает тип синтаксического отношения, которое связывает ребенка с голова. Как и в случае с другими атрибутами, значение .dep является хеш-значением. Ты можешь получить строковое значение с . dep_ .

  импорт просторный

nlp = spacy.load ("en_core_web_sm")
doc = nlp («Автономные автомобили переносят страхование ответственности на производителей»)
для токена в документе:
    print (token.text, token.dep_, token.head.text, token.head.pos_,
            [ребенок для ребенка в жетоне.дети])
  

• Текст: Исходный текст токена.
• Dep: Синтаксическое отношение, связывающее дочерний элемент с головой.
• Текст заголовка: Исходный текст токена головы.
• Head POS: Тег части речи токен-головки.
• Потомки: Непосредственные синтаксические зависимости токена.

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

  импорт прост.
из spacy.symbols import nsubj, VERB

nlp = spacy.load ("en_core_web_sm")
doc = nlp («Автономные автомобили переносят страхование ответственности на производителей»)


глаголы = набор ()
для possible_subject в документе:
    if possible_subject.dep == nsubj и possible_subject.head.pos == ГЛАГОЛ:
        verbs.add (possible_subject.глава)
печать (глаголы)
  

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

 
глаголы = []
для possible_verb в документе:
    если возможно_verb.pos == ГЛАГОЛ:
        для possible_subject в possible_verb.children:
            если возможно_subject.dep == nsubj:
                verbs.append (возможно_глагол)
                перерыв
  

Для перебора дочерних элементов используйте атрибут token. children , который предоставляет последовательность объектов Token .

Итерация по локальному дереву

Есть еще несколько удобных атрибутов для итерации по локальному дереву. дерево из жетона. Token.lefts и Token.rights Атрибуты обеспечивают последовательности синтаксических дочерние элементы, которые появляются до и после токена. Обе последовательности в предложении заказывать. Также есть два атрибута целочисленного типа: Token.n_lefts и Token.n_rights , которые дают количество левых и правых дети.

  импорт просторный

nlp = простор.load ("en_core_web_sm")
doc = nlp («ярко-красные яблоки на дереве»)
print ([token.text для токена в doc [2] .lefts])
print ([token.text для токена в doc [2] .rights])
печать (документ [2] .n_lefts)
печать (документ [2] .n_rights)
  

  импорт просторный

nlp = spacy.load ("de_core_news_sm")
doc = nlp ("schöne rote Äpfel auf dem Baum")
print ([token. text для токена в doc [2] .lefts])
print ([token.text для токена в doc [2] .rights])
  

Вы можете получить целую фразу по ее синтаксическому заголовку, используя Жетон.атрибут поддерева . Это возвращает заказанный последовательность жетонов. Вы можете подняться на дерево с помощью Token.ancestors атрибут и проверьте доминирование с помощью Token.is_ancestor

Проективное и непроективное

Для английских конвейеров по умолчанию дерево синтаксического анализа выглядит следующим образом: проекционная , что означает отсутствие перекрестных скобок. Жетоны возвращенный .subtree , следовательно, гарантированно будет непрерывным. Это не верно для немецких трубопроводов, у которых много непроективные зависимости.

  импорт просторный

nlp = spacy.load ("en_core_web_sm")
doc = nlp («Владельцы кредитных и ипотечных счетов должны подавать свои запросы»)

root = [токен для токена в документе if token. head == токен] [0]
subject = list (root.lefts) [0]
для потомка в subject.subtree:
    утверждать, что субъект является потомком или субъектом. is_ancestor (потомок)
    печать (потомок.текст, потомок.dep_, потомок.n_lefts,
            Потомок .n_rights,
            [ancestor.text для предка в потомке .ancestors])
  

Наконец, .Атрибуты left_edge и .right_edge могут быть особенно полезны, потому что они дают вам первый и последний токены поддерева. Это Самый простой способ создать объект Span для синтаксической фразы. Обратите внимание, что .right_edge дает токен внутри поддерева - поэтому, если вы используете его как конечная точка диапазона, не забудьте +1 !

  импорт просторный

nlp = spacy.load ("en_core_web_sm")
doc = nlp («Владельцы кредитных и ипотечных счетов должны подавать свои запросы»)
span = doc [doc [4].left_edge.i: документ [4] .right_edge.i + 1]
с doc.retokenize () в качестве ретокенизатора:
    retokenizer.merge (диапазон)
для токена в документе:
    print (token.text, token.pos_, token.dep_, token.head.text)
  

Анализ зависимостей может быть полезным инструментом для извлечения информации , особенно в сочетании с другими прогнозами, такими как названные объекты. В следующем примере извлекаются деньги и значения валюты, то есть сущности, помеченные как ДЕНЬГИ , а затем использует зависимость выполните синтаксический анализ, чтобы найти именную фразу, к которой они относятся — например, «Чистая прибыль» → «9,4 миллиона долларов» .

  импорт просторный

nlp = spacy.load ("en_core_web_sm")

nlp.add_pipe ("merge_entities")
nlp.add_pipe ("merge_noun_chunks")

ТЕКСТЫ = [
    «Чистая прибыль составила 9,4 миллиона долларов по сравнению с 2,7 миллиона долларов в предыдущем году»,
    «Выручка превысила двенадцать миллиардов долларов, а убыток составил 1 миллиард долларов.",
]
для документа в nlp.pipe (ТЕКСТЫ):
    для токена в документе:
        если token.ent_type_ == "ДЕНЬГИ":
            
            если token.dep_ in ("attr", "dobj"):
                subj = [w вместо w в token.head.lefts, если w.dep_ == "nsubj"]
                если subj:
                    print (subj [0], "->", токен)
            
            elif token. dep_ == "pobj" и token.head.dep_ == "Prep":
                print (token.head.head, "->", токен)
  

📖Комбинирование моделей и правил

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

Визуализация зависимостей

Лучший способ понять анализатор зависимостей spaCy — интерактивный. Делать это проще, spaCy поставляется с модулем визуализации. Вы можете сдать Doc или список объектов Doc для отображения и запуска displacy.serve для запуска веб-сервера или displacy.render для создания необработанной разметки. Если вы хотите знать, как писать правила, которые подключаются к синтаксису конструкции, просто вставьте предложение в визуализатор и посмотрите, как spaCy аннотирует это.

  импорт просторный
от просторного импорта

nlp = spacy. load ("en_core_web_sm")
doc = nlp («Автономные автомобили переносят страхование ответственности на производителей»)

displacy.render (док,)
  

Подробнее и примеры см. руководство по визуализации spaCy. Вы также можете протестировать Отображение в нашей онлайн-демонстрации.

Отключение парсера

В обученных конвейерах, предоставляемых spaCy, парсер загружается и включен по умолчанию как часть стандартный технологический конвейер.Если тебе не нужно любую синтаксическую информацию следует отключить парсер. Отключение парсер заставит spaCy загружаться и работать намного быстрее. Если вы хотите загрузить парсер, но необходимо отключить его для определенных документов, вы также можете контролировать его использование на объект nlp . Для получения дополнительной информации см. Руководство по использованию на отключение компонентов конвейера.

  nlp = spacy.load ("en_core_web_sm", disable = ["parser"])
  

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

Распознавание именованных объектов 101

Именованные объекты — это «объекты реального мира», которым присвоено имя, например человек, страна, продукт или название книги. spaCy может распознавать различные типы именованных сущностей в документе, запрашивая модель для предсказание .Поскольку модели являются статистическими и сильно зависят от примеры, на которых они были обучены, это не всегда работает идеально и может потребуются некоторые настройки позже, в зависимости от вашего варианта использования.

Именованные сущности доступны как свойство ents Doc :

  import spacy

nlp = spacy.load ("en_core_web_sm")
doc = nlp («Apple собирается купить британский стартап за 1 миллиард долларов»)

для Ent в док.  центрах:
    print (ent.text, ent.start_char, ent.end_char, ent.label_)
  

• Текст: Исходный текст объекта.
• Начало: Индекс начала объекта в Doc .
• Конец: Указатель конца объекта в Doc .
• Метка: Метка объекта, т.е. тип.

Текст	Начало	Конец	Этикетка	Описание
Apple	0	5	ORG	Компании, учреждения, учреждения.
Великобритания	27	31	GPE	Геополитическое образование, то есть страны, города, государства.
1 миллиард долларов	44	54	ДЕНЬГИ	Денежное выражение, включая единицы.

Используя встроенный визуализатор дисплея spaCy, вот что Наш примерное предложение и его именованные сущности выглядят так:

Доступ к аннотациям и меткам сущностей

Стандартный способ доступа к аннотациям сущностей — это doc.энц Свойство, которое создает последовательность из Span объектов. Лицо Тип доступен либо как хеш-значение, либо как строка с использованием атрибутов ent.label и ent.label_ . Объект Span действует как последовательность токенов, поэтому вы можете перебирать объект или индексировать его. Вы также можете получить текстовую форму целого объекта, как если бы это был один токен.

Вы также можете получить доступ к аннотациям токенов, используя токен.ent_iob и token.ent_type атрибутов. token.ent_iob указывает независимо от того, начинается ли объект, продолжается или заканчивается на теге. Если тип объекта не установлен на токене он вернет пустую строку.

Схема IOB

• I — Токен внутри объекта.
• O — Токен за пределами объекта.
• B — Токен — это , начинающийся с объекта.

Схема BILUO

• B — Токен — это начало мульти-токен-объекта.
• I — Токен внутри мульти-токен-объекта.
• L — Токен — это последний токен для объекта с несколькими токенами.
• U — Токен представляет собой единицу с одним токеном .
• O — Toke — это за пределами объекта.

  импорт просторный

nlp = spacy.load ("en_core_web_sm")
doc = nlp ("Сан-Франциско рассматривает вопрос о запрете роботов для доставки тротуаров")


ents = [(e.text, e.start_char, e.end_char, e.label_) для e в документах]
печать (энц)


ent_san = [doc [0] . text, doc [0] .ent_iob_, doc [0] .ent_type_]
ent_francisco = [документ [1] .text, doc [1] .ent_iob_, doc [1] .ent_type_]
печать (ent_san)
печать (ent_francisco)
  

Настройка аннотаций сущности

Чтобы гарантировать, что последовательность аннотаций токенов остается неизменной, вы должны установить аннотации сущностей на уровне документа . Однако вы не можете писать непосредственно к атрибутам token.ent_iob или token.ent_type , поэтому самый простой способ установки сущностей - использовать функцию doc.set_ents и создайте новый объект как Span .

  импорт просторный
из spacy.tokens import Span

nlp = spacy.load ("en_core_web_sm")
doc = nlp ("fb нанимает нового вице-президента по глобальной политике")
ents = [(e.text, e.start_char, e.end_char, e.label_) для e в документах]
print ('До', энц)



fb_ent = Span (doc, 0, 1, label = "ORG")
orig_ents = список (док.энц)


doc.set_ents ([fb_ent], по умолчанию = "без изменений")


doc.ents = orig_ents + [fb_ent]

ents = [(e.text, e.start, e.end, e.label_) для e в документах]
print ('После', энц)

  

Имейте в виду, что Span инициализируется начальным и конечным токенами индексы, а не смещения символов. Чтобы создать диапазон из смещений символов, используйте Doc. char_span :

  fb_ent = doc.char_span (0, 2, label = "ORG")
  

Установка аннотаций сущностей из массива

Вы также можете назначить аннотации сущностей с помощью док.from_array метод. Для этого следует включить атрибуты ENT_TYPE и ENT_IOB в массиве, который вы импортируете из.

  импортный номер
импортный простор
из spacy.attrs импортировать ENT_IOB, ENT_TYPE

nlp = spacy.load ("en_core_web_sm")
doc = nlp.make_doc («Лондон - большой город в Соединенном Королевстве.»)
print («До», док.)

заголовок = [ENT_IOB, ENT_TYPE]
attr_array = numpy.zeros ((len (документ), len (заголовок)), dtype = "uint64")
attr_array [0, 0] = 3
attr_array [0, 1] = док.Vocalab.strings ["GPE"]
doc.from_array (заголовок, attr_array)
print ("После", док.)
  

Установка аннотаций сущностей в Cython

Наконец, вы всегда можете записать в базовую структуру, если скомпилируете Функция Cython. Это легко сделать и позволяет писать эффективный нативный код.

 
из spacy.typedefs cimport attr_t
из spacy.tokens.doc cimport Doc

cpdef set_entity (документ doc, int start, int end, attr_t ent_type):
    для i в диапазоне (начало, конец):
        док.c [i] .ent_type = ent_type
    doc.c [начало] .ent_iob = 3
    для i в диапазоне (начало + 1, конец):
        doc.c [i] .ent_iob = 2
  

Очевидно, что если вы напишете непосредственно в массив структур TokenC * , у вас будет ответственность за обеспечение того, чтобы данные оставались в согласованном состоянии.

Встроенные типы сущностей

Совет: понимание типов сущностей

Вы также можете использовать spacy.explain () для получения описания строки представление метки объекта.Например, spacy.explain ("ЯЗЫК") вернет «любой названный язык».

Схема аннотаций

Подробнее о типах сущностей, доступных в обученных конвейерах spaCy, см. «Схема маркировки» отдельных моделей в каталог моделей.

Визуализация именованных сущностей

дисплей ^{визуализатор ЛОР} позволяет интерактивно исследовать поведение модели распознавания сущностей. Если ты при обучении модели очень полезно запускать визуализацию самостоятельно.Помогать вы делаете это, spaCy поставляется с модулем визуализации. Вы можете сдать Doc или список объектов Doc для отображения и запуска displacy.serve для запуска веб-сервера или displacy.render для создания необработанной разметки.

Подробнее и примеры см. руководство по визуализации spaCy.

  
 Пример именованного объекта 
   import spacy
от просторного импорта

text = "Когда Себастьян Трун в 2007 году начал работать над беспилотными автомобилями в Google, мало кто из других людей воспринимал его всерьез."

nlp = spacy.load ("en_core_web_sm")
doc = nlp (текст)
displacy.serve (док,)
  

Чтобы закрепить названные объекты в «реальном мире», spaCy предоставляет функциональные возможности для выполнения привязки сущностей, которая разрешает текстовую сущность в уникальную идентификатор из базы знаний (КБ). Вы можете создать свой собственный KnowledgeBase и обучите нового EntityLinker с использованием этой настраиваемой базы знаний.

Доступ к идентификаторам объектов Требуется модель

Аннотированный идентификатор KB доступен либо в виде хеш-значения, либо в виде строки, используя атрибуты ent.kb_id и ent.kb_id_ из диапазона объект или атрибуты ent_kb_id и ent_kb_id_ объекта Token объект.

  импорт просторный

nlp = spacy.load ("my_custom_el_pipeline")
doc = nlp («Ада Лавлейс родилась в Лондоне»)


ents = [(e.text, e.label_, e.kb_id_) для e в документах]
печать (энц)


ent_ada_0 = [doc [0] .text, doc [0] .ent_type_, doc [0] .ent_kb_id_]
ent_ada_1 = [документ [1] .text, doc [1] .ent_type_, doc [1] .ent_kb_id_]
ent_london_5 = [документ [5].текст, doc [5] .ent_type_, doc [5] .ent_kb_id_]
печать (ent_ada_0)
печать (ent_ada_1)
печать (ent_london_5)
  

Токенизация - это задача разбиения текста на значимые сегменты, называемые жетонов . Входными данными токенизатора является текст в Юникоде, а на выходе - Объект Doc . Чтобы построить объект Doc , вам понадобится Экземпляр Vocab , последовательность из строк слов и, необязательно, последовательность пробелов логических значений, которые позволяют поддерживать выравнивание токены в исходную строку.

Важное примечание

spaCy токенизация неразрушающий , что означает, что вы всегда будете может восстановить исходный ввод из токенизированного вывода. Пробел информация сохраняется в токенах, и никакая информация не добавляется и не удаляется во время токенизации. Это своего рода основной принцип объекта spaCy Doc : doc.text == input_text всегда должно выполняться.

Во время обработки spaCy first токенизирует текст, т.е.е. сегментирует его на слова, знаки препинания и так далее. Это делается путем применения правил, специфичных для каждого язык. Например, знаки препинания в конце предложения следует разделять. - тогда как «Великобритания» должен остаться один жетон. Каждый Doc состоит из отдельных токены, и мы можем перебирать их:

  import spacy

nlp = spacy.load ("en_core_web_sm")
doc = nlp («Apple собирается купить британский стартап за 1 миллиард долларов»)
для токена в документе:
    печать (токен.текст)
  

Сначала необработанный текст разбивается на пробельные символы, аналогично text. split ('') . Затем токенизатор обрабатывает текст слева направо. На для каждой подстроки выполняется две проверки:

1. Соответствует ли подстрока правилу исключения токенизатора? Например, «не надо» не содержит пробелов, но должен быть разделен на два токена: «do» и «Нет», а «У.К. » всегда должен оставаться один жетон.

2. Можно ли отделить префикс, суффикс или инфикс? Например, знаки препинания запятые, точки, дефисы или кавычки.

Если есть совпадение, правило применяется, и токенизатор продолжает цикл, начиная с недавно разделенных подстрок. Таким образом, spaCy может разделить комплекс , вложенные токены , такие как комбинации сокращений и множественных знаков препинания Метки.

• Исключение токенизатора: Особое правило для разделения строки на несколько токены или предотвратить разделение токена, когда правила пунктуации применяемый.
• Префикс: символов в начале, например $ , (, “, ¿.
• Суффикс: символов в конце, например, км , ) , ” , ! .
• Инфикс: Знак (и) между ними, например - , - , /, … .

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

Подробности алгоритма: как работает токенизатор spaCy¶

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

После использования префикса или суффикса мы снова обращаемся к особым случаям. Мы хотим особые случаи, чтобы обрабатывать такие вещи, как "не" на английском языке, и мы хотим того же Правило работать на «(не)!». Мы делаем это, отделяя открытую скобку, затем восклицательный знак, затем закрытая скобка и, наконец, соответствующий особый случай. Вот реализация алгоритма на Python, оптимизированная для удобочитаемости. а не производительность:

  def tokenizer_pseudo_code (
    текст,
    Особые случаи,
    prefix_search,
    суффикс_поиск,
    infix_finditer,
    token_match,
    url_match
):
    токены = []
    для подстроки в text.split ():
        суффиксы = []
        пока подстрока:
            в то время как prefix_search (подстрока) или suffix_search (подстрока):
                если token_match (подстрока):
                    жетоны.добавить (подстрока)
                    substring = ""
                    перерыв
                если подстрока в special_cases:
                    tokens.extend (special_cases [подстрока])
                    substring = ""
                    перерыв
                если prefix_search (подстрока):
                    split = prefix_search (подстрока) . end ()
                    tokens.append (подстрока [: split])
                    подстрока = подстрока [разделить:]
                    если подстрока в special_cases:
                        Продолжать
                если суффикс_поиск (подстрока):
                    split = суффикс_поиск (подстрока).Начало()
                    суффиксы.append (подстрока [разделить:])
                    подстрока = подстрока [: разделение]
            если token_match (подстрока):
                tokens.append (подстрока)
                substring = ""
            elif url_match (подстрока):
                tokens.append (подстрока)
                substring = ""
            Подстрока elif в special_cases:
                tokens.extend (special_cases [подстрока])
                substring = ""
            список elif (infix_finditer (подстрока)):
                infixes = infix_finditer (подстрока)
                смещение = 0
                для соответствия в инфиксах:
                    жетоны. добавить (подстрока [смещение: match.start ()])
                    tokens.append (подстрока [match.start (): match.end ()])
                    смещение = match.end ()
                если подстрока [смещение:]:
                    tokens.append (подстрока [смещение:])
                substring = ""
            Подстрока elif:
                tokens.append (подстрока)
                substring = ""
        tokens.extend (в обратном порядке (суффиксы))
    для совпадения в сопоставлении (special_cases, text):
        tokens.replace (совпадение, особые_случаи [совпадение])
    вернуть жетоны
  

Алгоритм можно резюмировать следующим образом:

1. Итерация по подстрокам, разделенным пробелами.
2. Найдите совпадение по токену. Если есть совпадение, остановите обработку и оставьте это токен.
3. Проверьте, есть ли у нас явно определенный особый случай для этой подстроки. Если да, используйте это.
4. В противном случае попробуйте использовать один префикс. Если мы использовали префикс, вернитесь к # 2, так что совпадение токенов и особые случаи всегда имеют приоритет.
5. Если мы не использовали префикс, попробуйте использовать суффикс, а затем вернитесь к №2.
6. Если мы не можем использовать префикс или суффикс, ищите соответствие URL.
7. Если URL не соответствует, ищите особый случай.
8. Найдите «инфиксы» - например, дефисы и т. Д. И разделите подстроку на токены на всех инфиксах.
9. Как только мы больше не сможем потреблять строку, обрабатываем ее как отдельный токен.
10. Сделайте последний проход по тексту, чтобы проверить наличие особых случаев, которые включают пробелы или пропущенные из-за дополнительной обработки аффиксов.

Global и , зависящие от языка данные токенизатора предоставляются через язык данные в spacy / lang .Исключения токенизатора определите особые случаи, такие как «не» в английском языке, который нужно разделить на два токены: {ORTH: "do"} и {ORTH: "n't", NORM: "not"} . Приставки, суффиксы а инфиксы в основном определяют правила пунктуации - например, когда нужно отделить периоды (в конце предложения) и когда оставлять маркеры, содержащие точки неповрежденные (сокращения, например, «США»).

Следует ли мне изменить языковые данные или добавить собственные правила токенизатора? ¶

Правила токенизации, которые относятся к одному языку, но могут быть обобщенными через этот язык , в идеале должны жить в языковых данных в spacy / lang - мы всегда ценим запросы на включение! Все, что относится к домену или типу текста, например финансовая торговля. аббревиатуры или баварский молодежный сленг - следует добавлять в качестве особого правила к вашему экземпляру токенизатора.Если вы имеете дело с большим количеством настроек, это может иметь смысл создать полностью настраиваемый подкласс.

Добавление особых правил токенизации

Большинство доменов имеют по крайней мере некоторые особенности, требующие индивидуальной токенизации правила. Это могут быть очень определенные выражения или сокращения, используемые только в это конкретное поле. Вот как добавить правило особого случая к существующему Tokenizer instance:

  import spacy
из spacy.symbols import ORTH

nlp = простор.load ("en_core_web_sm")
doc = nlp ("дай мне это")
print ([w.text для w в документе])


special_case = [{ORTH: "gim"}, {ORTH: "me"}]
nlp.tokenizer.add_special_case ("дай мне", специальный_кейс)


print ([w.text для w в nlp ("дай мне это")])
  

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

  assert "gimme" not in [w.text for w in nlp ("gimme!")]
assert "gimme" not in [w.text for w in nlp ('("... дай мне ...?")')]

nlp.tokenizer.add_special_case ("... дай мне ...?", [{"ORTH": ". .. дай мне ...?"}])
assert len ​​(nlp ("... дай ...?")) == 1
  

Отладка токенизатора

Рабочая реализация приведенного выше псевдокода доступна для отладки как nlp.tokenizer.explain (текст) . Он возвращает список кортежи, показывающие, какое правило или шаблон токенизатора было сопоставлено для каждого токена.В произведенные токены идентичны nlp.tokenizer () , за исключением пробельных токенов:

Ожидаемый результат

  "ПРЕФИКС
Пусть СПЕЦИАЛЬНЫЙ-1
СПЕЦИАЛЬНЫЙ-2
перейти ТОКЕН
! СУФФИКС
"СУФФИКС
  

  из spacy.lang.en импорт английский

nlp = английский ()
text = '' '"Поехали!"' ''
doc = nlp (текст)
tok_exp = nlp.tokenizer.explain (текст)
assert [t.text для t в документе, если не t.is_space] == [t [1] для t в tok_exp]
для t в tok_exp:
    print (t [1], "\ t", t [0])
  

Настройка класса токенизатора spaCy

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

1. Словарь особых случаев . Это обрабатывает такие вещи, как схватки, единицы измерения, смайлы, некоторые сокращения и т. д.
2. Функция prefix_search , для обработки предшествующих знаков препинания , таких как открытая кавычки, открытые скобки и т. д.
3. Функция suffix_search для обработки следующих знаков препинания , таких как запятые, точки, закрывающие кавычки и т. д.
4. Функция infix_finditer для обработки непробельных разделителей, таких как дефисы и т. д.
5. Необязательная логическая функция token_match соответствующие строки, которые никогда не должны быть разделенным, переопределив правила инфиксов. Полезно для таких вещей, как числа.
6. Необязательная логическая функция url_match , аналогичная token_match за исключением того, что префиксы и суффиксы удаляются перед применением соответствия.

Обычно не требуется создавать подкласс Tokenizer . Стандартное использование использовать re.compile () для создания объекта регулярного выражения и передать его .https?: // '' ') def custom_tokenizer (nlp): вернуть Tokenizer (nlp.vocab, rules = special_cases, prefix_search = prefix_re.search, суффикс_поиск = суффикс_ре.поиск, infix_finditer = infix_re.finditer, url_match = simple_url_re.match) nlp = spacy.load ("en_core_web_sm") nlp.tokenizer = custom_tokenizer (nlp) doc = nlp ("привет-мир. :)") print ([t.text для t в документе])

Если вместо этого вам нужно создать подкласс токенизатора, соответствующие методы specialize - это find_prefix , find_suffix и find_infix .

Важное примечание

При настройке обработки префиксов, суффиксов и инфиксов помните, что вы передача функций для выполнения spaCy, например prefix_re. .Точно так же суффиксные правила должны применяется только к концу токена , поэтому ваше выражение должно заканчиваться $ .

Изменение существующих наборов правил

Во многих ситуациях вам не обязательно нужны полностью настраиваемые правила. Иногда вы просто хотите добавить еще один символ к префиксам, суффиксам или инфиксам. В правила префикса, суффикса и инфикса по умолчанию доступны через объект nlp По умолчанию и Tokenizer атрибуты, такие как Токенизатор.суффикс_поиск доступны для записи, поэтому вы можете перезаписать их скомпилированными объектами регулярного выражения, используя измененное значение по умолчанию правила. spaCy поставляется с служебными функциями, которые помогут вам скомпилировать обычный выражения - например, compile_suffix_regex :

  суффиксы = nlp.Defaults.suffixes + [r '' '- + $' '',]
суффикс_regex = spacy.util. compile_suffix_regex (суффиксы)
nlp.tokenizer.suffix_search = suffix_regex.search
  

Аналогичным образом вы можете удалить символ из суффиксов по умолчанию:

  suffixes = list (nlp.Defaults.suffixes)
суффиксы.remove ("\\ [")
суффикс_regex = spacy.util.compile_suffix_regex (суффиксы)
nlp.tokenizer.suffix_search = suffix_regex.search
  

Атрибут Tokenizer.suffix_search должен быть функцией, которая принимает строка Unicode и возвращает объект соответствия регулярному выражению или Нет . Обычно мы используем атрибут .search скомпилированного объекта регулярного выражения, но вы можете использовать и другие функция, которая ведет себя так же.

Важное примечание

Если вы загрузили обученный конвейер, запись в нлп.Значения по умолчанию или на английском языке. Значения по умолчанию напрямую не используются. работают, поскольку регулярные выражения считываются из данных конвейера и будут компилируется при загрузке. Если вы измените nlp.Defaults , вы увидите только эффект, если вы позвоните spacy.blank . Если вы хотите изменить токенизатор, загруженный из обученного конвейера, вы должны изменить nlp.tokenizer напрямую. Если вы тренируете собственный конвейер, вы можете зарегистрироваться обратные вызовы для изменения nlp объект перед тренировкой.

Наборы правил для префиксов, инфиксов и суффиксов включают не только отдельные символы. но также подробные регулярные выражения, которые принимают окружающий контекст в учетная запись. Например, существует регулярное выражение, которое обрабатывает дефис между буквы как инфикс. Если вы не хотите, чтобы токенизатор разбивался на дефисы между буквами, вы можете изменить существующее определение инфикса из lang / punctuation.py :

  import spacy
из spacy.lang.char_classes импортировать ALPHA, ALPHA_LOWER, ALPHA_UPPER
от простора.] (? = [0-9-]) ",
        r "(? <= [{al} {q}]) \.  (? = [{au} {q}]]". format (
            al = ALPHA_LOWER, au = ALPHA_UPPER, q = CONCAT_QUOTES
        ),
        r "(? <= [{a}]), (? = [{a}])". format (a = ALPHA),
        
        
        r "(? <= [{a} 0-9]) [: <> = /] (? = [{a}])". format (a = ALPHA),
    ]
)

infix_re = compile_infix_regex (инфиксы)
nlp.tokenizer.infix_finditer = infix_re.finditer
doc = nlp ("свекровь")
print ([t.text для t в документе])
  

Обзор регулярных выражений по умолчанию см. языков / знаков препинания.py и специфичные для языка определения, такие как lang / de / punctuation.py для Немецкий.

Подключение пользовательского токенизатора к конвейеру

Токенизатор является первым и единственным компонентом конвейера обработки. это не может быть заменено записью на nlp.pipeline . Это потому, что у него отличная подпись от всех других компонентов: он принимает текст и возвращает Doc , тогда как все остальные компоненты ожидают уже получить токенизированные Doc .

Чтобы перезаписать существующий токенизатор, вам необходимо заменить nlp.tokenizer на настраиваемая функция, которая принимает текст и возвращает Doc .

Создание документа Doc

Для создания объекта Doc вручную требуется не менее двух аргументы: общий Vocab и список слов. По желанию можно сдать список из пробелов значений, указывающих, является ли токен в этой позиции с последующим пробелом (по умолчанию True ).См. Раздел о предварительно токенизированный текст для получения дополнительной информации.

  words = [«Пусть», «s», «go», «!»]
пробелы = [Ложь, Истина, Ложь, Ложь]
doc = Doc (nlp.vocab, слова = слова, пробелы = пробелы)
  

  nlp = spacy.blank ("en")
nlp.tokenizer = my_tokenizer
  

Аргумент	Тип	Описание
текст	str	Необработанный текст для токенизации.

Пример 1. Базовый токенизатор пробелов

Вот пример самого простого токенизатора пробелов.Требуется общий словарь, поэтому он может создавать объекты Doc . Когда он вызывает текст, он возвращает объект Doc , состоящий из текста, разделенного на одиночные пробелы. Мы можем затем перезапишите атрибут nlp.tokenizer экземпляром нашего настраиваемого токенизатор.

  импорт просторный
из spacy.tokens import Doc

класс WhitespaceTokenizer:
    def __init __ (я, словарь):
        self.vocab = словарный запас

    def __call __ (сам, текст):
        слова = текст.расколоть(" ")
        вернуть документ (self.vocab, words = words)

nlp = spacy.blank ("ru")
nlp.tokenizer = WhitespaceTokenizer (nlp.vocab)
doc = nlp («Что со мной случилось? подумал он. Это был не сон.»)
print ([token.text для токена в документе])
  

Пример 2: Сторонние токенизаторы (части слова BERT)

Вы можете использовать тот же подход для подключения любых других сторонних токенизаторов. Ваш custom callable просто нужно вернуть объект Doc с токенами, созданными ваш токенизатор.В этом примере оболочка использует слово BERT. токенизатор , предоставленный токенизаторов библиотеки. Жетоны доступный в объекте Doc , возвращенном spaCy, теперь соответствует точным частям слова производится токенизатором.

💡 Совет: spacy-transformers

Если вы работаете с моделями трансформаторов, такими как BERT, ознакомьтесь с Пространственно-трансформеры пакет расширений и документация. Это включает компонент конвейера для использования предварительно обученных грузов трансформатора и Тренировочный трансформатор модели в spaCy, а также полезные утилиты для согласование частей слова с лингвистической лексикой.

  
 Custom BERT word piece tokenizer 
   from tokenizers import BertWordPieceTokenizer
из spacy.tokens import Doc
импортный простор

класс BertTokenizer:
    def __init __ (я, словарь, файл словаря, нижний регистр = Истина):
        self. vocab = словарный запас
        self._tokenizer = BertWordPieceTokenizer (файл словаря, нижний регистр = нижний регистр)

    def __call __ (сам, текст):
        tokens = self._tokenizer.encode (текст)
        слова = []
        пробелы = []
        для i, (текст, (начало, конец)) в перечислении (zip (tokens.токены, токены. смещения)):
            words.append (текст)
            если i  конец)
            еще:
                space.append (Истина)
        вернуть документ (self.vocab, слова = слова, пробелы = пробелы)

nlp = spacy.blank ("ru")
nlp.tokenizer = BertTokenizer (nlp.vocab, "bert-base-uncased-vocab.txt")
doc = nlp ("Джастин Дрю Бибер - канадский певец, автор песен и актер.")
print (doc.text, [token.text для токена в документе])



  

Важное примечание о токенизации и моделях

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

Обучение с пользовательской токенизацией v3.0

spaCy описывает настройки, гиперпараметры, конвейер и токенизатор, используемые для построения и обучения трубопровод. Блок [nlp.tokenizer] относится к зарегистрированной функции , которая принимает объект nlp и возвращает токенизатор. Здесь мы регистрируем функция называется whitespace_tokenizer в Реестр @tokenizers . Чтобы убедиться, что spaCy умеет построить свой токенизатор во время обучения, вы можете передать свой файл Python с помощью установка - код функции.py при запуске spacy train .

config.cfg

  [nlp.tokenizer]
@tokenizers = "whitespace_tokenizer"
  

  
 functions.py 
   @ spacy.registry.tokenizers ("whitespace_tokenizer") def create_whitespace_tokenizer ():
    def create_tokenizer (nlp):
        вернуть WhitespaceTokenizer (nlp.vocab)

    вернуть create_tokenizer
  

Зарегистрированные функции также могут принимать аргументы, которые затем передаются из config. Это позволяет быстро изменять и отслеживать различные настройки.Здесь зарегистрированная функция bert_word_piece_tokenizer занимает два аргументы: путь к файлу словаря и необходимость строчных букв. В Подсказки типа Python str и bool гарантируют, что полученные значения имеют правильный тип.

config.cfg

  [nlp.tokenizer]
@tokenizers = "bert_word_piece_tokenizer"
Vocab_file = "bert-base-uncased-vocab.txt"
нижний регистр = истина
  

  
 functions.
 py    @spacy.registry.tokenizers ("bert_word_piece_tokenizer") def create_whitespace_tokenizer (vocab_file: str, нижний регистр: bool):
    def create_tokenizer (nlp):
        вернуть BertWordPieceTokenizer (nlp.vocab, vocab_file, строчные буквы)

    вернуть create_tokenizer
  

Чтобы избежать жесткого кодирования локальных путей в файле конфигурации, вы также можете установить Vocab путь в CLI с помощью переопределения --nlp.tokenizer.vocab_file при запуске Большой поезд . Для получения более подробной информации об использовании зарегистрированных функций, см. документацию по обучению с пользовательским кодом.

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

Использование предварительно токенизированного текста

spaCy обычно предполагает по умолчанию, что ваши данные - это необработанный текст . Тем не мение, иногда ваши данные частично аннотируются, например.грамм. с уже существующей токенизацией, теги части речи и т. д. Чаще всего у вас предопределенная токенизация . Если у вас есть список строк, вы можете создать Doc объект напрямую. При желании вы также можете указать список логические значения, указывающие, следует ли за каждым словом пробел.

✏️ Что попробовать

1. Измените логическое значение в списке пробелов . Вы должны увидеть это в отражении в doc.text и следует ли за токеном пробел.
2. Удалите пробелов = пробелы из Doc . Вы должны увидеть, что каждый токен теперь следует пробел.
3. Скопируйте и вставьте случайное предложение из Интернета и вручную создайте Doc с словами и пробелами , так что doc. text совпадает с оригиналом ввод текста.

  импорт просторный
из spacy.tokens import Doc

nlp = spacy.blank ("ru")
words = ["Привет", ",", "мир", "!"]
пробелы = [Ложь, Истина, Ложь, Ложь]
doc = Док (nlp.словарь, слова = слова, пробелы = пробелы)
печать (doc.text)
print ([(t.text, t.text_with_ws, t.whitespace_) для t в документе])
  

Если предоставляется, список пробелов должен быть той же длины, что и список слов, . В Список пробелов влияет на doc.text , span.text , token.idx , span.start_char и атрибутов span.end_char . Если вы не укажете последовательность пробелов и , spaCy будет считать, что после всех слов стоит пробел.Как только у вас будет Doc объект, вы можете записать в его атрибуты, чтобы установить теги части речи, синтаксические зависимости, именованные объекты и другие атрибуты.

Согласование токенизации

Токенизация spaCy является неразрушающей и использует правила, зависящие от языка оптимизирован для совместимости с аннотациями банка деревьев. Другие инструменты и ресурсы может иногда токенизировать вещи по-разному - например, «Я» → [«I», «'», «m»] вместо [«I», «m»] .

В подобных ситуациях вам часто нужно выровнять токенизацию, чтобы может объединять аннотации из разных источников вместе или брать предсказанные векторы автор предварительно обученная модель BERT и примените их к токенам spaCy. spaCy’s Выравнивание объект позволяет однозначно отображать индексы токенов в обоих направлениях, как а также с учетом индексов, в которых несколько токенов совпадают с одним токен.

✏️ Что попробовать

1. Измените регистр в одном из списков токенов - например, «Обама» по «Обама» .Вы увидите, что при выравнивании регистр не учитывается.
2. Измените «подкасты» в other_tokens на «pod», «cast» . Тебе следует увидеть что теперь есть два токена длины 2 в y2x , один соответствует «S», а один - «подкасты».
3. Сделайте other_tokens и spacy_tokens идентичными. Вы увидите, что все токены теперь соответствуют 1 к 1.

  из spacy.training import Alignment

other_tokens = [«я», «слушал», «до», «обама», «'», «с», «подкасты», «."]
spacy_tokens = ["я", "слушал", "кому", "обама", "s", "подкасты", "."]
align = Alignment.from_strings (other_tokens, spacy_tokens)
print (f "a -> b, lengths: {align.x2y.lengths}")
print (f "a -> b, сопоставление: {align.x2y.dataXd}")
print (f "b -> a, lengths: {align.y2x.lengths}")
print (f "b -> a, сопоставления: {align.y2x.dataXd}")
  

Вот некоторые выводы из информации о выравнивании, сгенерированной в примере выше:

• Сопоставления "один-к-одному" для первых четырех токенов идентичны, что означает они сопоставляются друг с другом.Это имеет смысл, потому что они идентичны и в ввод: "я" , "слушал" , "до" и "обама" .
• Значение x2y. dataXd [6] равно 5 , что означает, что other_tokens [6] ( «подкасты», ) соответствуют spacy_tokens [5] (также «подкасты» ).
• x2y.dataXd [4] и x2y.dataXd [5] оба равны 4 , что означает, что оба токена 4 и 5 из other_tokens ( "'" и "s" ) выравниваются с токеном 4 из spacy_tokens ( "х" ).

Важное примечание

Текущая реализация алгоритма выравнивания предполагает, что оба токенизации складываются в одну и ту же строку. Например, вы сможете выровнять [«Я», «'», «м»] и [«Я», «м»] , которые в сумме дают «Я» , но не [«я», «м»] и [«я», «ам»] .

Диспетчер контекста Doc.retokenize позволяет объединять и разделить токены. Изменения токенизации сохраняются и выполняются на один раз при выходе из диспетчера контекста. Объединить несколько токенов в один токен, передайте Span в ретокенизатор .merge . An дополнительный словарь attrs позволяет вам установить атрибуты, которые будут назначены объединенный токен - например, лемма, тег части речи или тип объекта. От по умолчанию объединенный токен получит те же атрибуты, что и объединенный диапазон корень.

✏️ Что попробовать

1. Проверьте атрибут token.lemma_ с установкой и без установки attrs .Вы увидите, что в лемме по умолчанию используется «New», лемма о корне span.
2. Перезаписать другие атрибуты, такие как "ENT_TYPE" . Поскольку «Нью-Йорк» тоже распознается как именованный объект, это изменение также будет отражено в док. .

  импорт просторный

nlp = spacy.load ("en_core_web_sm")
doc = nlp («Я живу в Нью-Йорке»)
print ("До:", [token.text для токена в документе])

с doc.retokenize () в качестве ретокенизатора:
    retokenizer. merge (документ [3: 5], attrs = {"ЛЕММА": "нью-йорк"})
print ("После:", [токен.текст для токена в документе])
  

Совет: объединение сущностей и словосочетаний с существительными

Если вам нужно объединить именованные сущности или фрагменты существительных, воспользуйтесь встроенным merge_entities и merge_noun_chunks конвейер составные части. При добавлении в конвейер с помощью nlp.add_pipe они займут забота об автоматическом слиянии пролетов.

Если атрибут в attrs является контекстно-зависимым атрибутом токена, он будет применяться к базовому токену .Например LEMMA , POS или DEP применяются только к слову в контексте, поэтому они являются атрибутами токена. Если attribute является контекстно-независимым лексическим атрибутом, он будет применяться к Лексема , лежащая в основе , запись в словаре. Например, LOWER или IS_STOP применяются ко всем словам с одинаковым написанием, независимо от контекст.

Примечание по объединению перекрывающихся промежутков

Если вы пытаетесь объединить перекрывающиеся промежутки, spaCy выдаст ошибку, потому что неясно, как должен выглядеть результат.В зависимости от приложения вы можете хотите найти самый короткий или самый длинный диапазон, поэтому вам решать, как отфильтровать их. Если вы ищете самый длинный неперекрывающийся промежуток, вы можете использовать util.filter_spans helper:

  doc = nlp («Я живу в Берлинском Кройцберге»)
spans = [документ [3: 5], документ [3: 4], документ [4: 5]]
filter_spans = filter_spans (промежутки)
  

Разделение токенов

Метод retokenizer.split позволяет разделить один жетон на два или более жетона.Это может быть полезно в тех случаях, когда Одних правил токенизации недостаточно. Например, вы можете захотеть разделить «Его» в токены «оно» и «есть», но не притяжательное местоимение «его». Ты может написать логику, основанную на правилах, которая может найти только правильное «свое» для разделения, но к этому времени Doc уже будет токенизирован.

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

✏️ Что стоит попробовать

1. Назначьте различные атрибуты подтокенам и сравните результат.
2. Измените головки так, чтобы «New» было прикреплено к «in», а «York» - прикреплено. на «Новый».
3. Разделите жетон на три жетона вместо двух - например, [«Новый», «Йо», «рк»] .

  импорт просторный
от просторного импорта

nlp = spacy.load ("en_core_web_sm")
doc = nlp («Я живу в Нью-Йорке»)
print ("До:", [token. text для токена в документе])
displacy.render (док)

с doc.retokenize () в качестве ретокенизатора:
    Heads = [(док [3], 1), док [2]]
    attrs = {"POS": ["PROPN", "PROPN"], "DEP": ["pobj", "соединение"]}
    retokenizer.split (doc [3], ["New", "York"], Heads = Heads, attrs = attrs)
print ("После:", [токен.текст для токена в документе])
displacy.render (док)
  

Указание заголовков в виде списка токенов или (токен, суб-токен) кортежей позволяет присоединение разделенных субтокенов к другим субтокенам без необходимости отслеживать индексы токенов после разделения.

Токен	Голова	Описание
«Новый»	(doc [3], 1)	Прикрепите этот токен ко второму подтексту (индекс 1 ) что doc [3] будет разделен на: i.е. «Йорк».
"York"	doc [2]	Прикрепите этот токен к doc [1] в исходном Doc , т. е. «in».

Если вас не волнуют головы (например, если вы используете только токенизатор, а не парсер), вы можете прикрепить каждый подтекен к себе:

  doc = nlp («Я живу в Нью-Йорке»)
с doc.retokenize () в качестве ретокенизатора:
    Heads = [(doc [3], 0), (doc [3], 1), (doc [3], 2)] ретокенизатор.split (doc [3], ["Новый", "Йорк", "Город"], Heads = Heads)
  

Важное примечание

При разделении токенов тексты суб токенов всегда должны совпадать с оригиналом текст токена - или, иначе говоря, "" .join (subtokens) == token.text всегда нужен чтобы быть правдой. Если бы это было не так, разделение токенов могло бы легко закончиться приводя к сбивающим с толку и неожиданным результатам, которые противоречили бы Политика неразрушающей токенизации.

  doc = nlp («Я живу в Лос-Анджелесе.")
с doc.retokenize () в качестве ретокенизатора:
- retokenizer.split (doc [3], ["Los", "Angeles"], Heads = [(doc [3], 1), doc [2]])
+ retokenizer. split (doc [3], ["L.", "A."], Heads = [(doc [3], 1), doc [2]])
  

Перезапись атрибутов настраиваемого расширения

Если вы зарегистрировали настраиваемый атрибуты расширения, вы можете перезаписать их во время токенизации, предоставив словарь имена атрибутов отображаются на новые значения как ключ "_" в атрибуте attrs . Для слияния, вам необходимо предоставить один словарь атрибутов для результирующего объединенный токен.Для разделения вам необходимо предоставить список словарей с настраиваемые атрибуты, по одному на каждый под токен разделения.

Важное примечание

Чтобы установить атрибуты расширения во время ретокенизации, атрибуты должны быть зарегистрировал с использованием Token.set_extension метод, и они должны быть с возможностью записи . Это означает, что они должны иметь значение по умолчанию, которое можно перезаписать, или установщики геттеров и . Метод расширения или расширения только с геттером вычисляются динамически, поэтому их значения не могут быть перезаписаны.Подробнее см. документация по атрибуту расширения.

✏️ Что стоит попробовать

1. Добавьте еще одно собственное расширение - может быть, "music_style" ? - и перезапишите его.
2. Измените атрибут расширения, чтобы использовать только функцию получения . Вам следует видите, что spaCy вызывает ошибку, потому что атрибут недоступен для записи больше.
3. Перепишите код, чтобы разделить токен на retokenizer.split . Помни это вам необходимо предоставить список значений атрибутов расширения в виде "_" Свойство, по одному на каждый разделенный подтекст.

  импорт просторный
из spacy.tokens импортировать токен


Token.set_extension ("is_musician", по умолчанию = False)

nlp = spacy.load ("en_core_web_sm")
doc = nlp («Мне нравится Дэвид Боуи»)
print ("До:", [(token. text, token ._. is_musician) для токена в документе])

с doc.retokenize () в качестве ретокенизатора:
    retokenizer.merge (документ [2: 4], attrs = {"_": {"is_musician": True}})
print ("После:", [(token.text, token ._. is_musician) для токена в документе])
  

A Doc Предложения объекта доступны через Doc.сент имущество. Чтобы просмотреть предложения Doc , вы можете перебрать Doc.sents , a генератор, который дает Span объекта. Вы можете проверить, действительно ли Doc имеет границы предложения, позвонив Doc.has_annotation с именем атрибута «SENT_START» .

  импорт просторный

nlp = spacy.load ("en_core_web_sm")
doc = nlp ("Это предложение. Это другое предложение.")
assert doc.has_annotation ("SENT_START")
для отправки в док.отправляет:
    печать (отправлено. текст)
  

spaCy предоставляет четыре альтернативы для сегментации предложений:

1. Анализатор зависимостей: статистический DependencyParser обеспечивает наиболее точный границы предложений, основанные на анализе полной зависимости.
2. Статистический сегментатор предложений: статистический SentenceRecognizer проще и быстрее альтернатива синтаксическому анализатору, который устанавливает только границы предложения.
3. Компонент конвейера на основе правил: основанный на правилах Sentencizer устанавливает границы предложения с помощью настраиваемый список знаков препинания в конце предложения.
4. Пользовательская функция: ваша собственная пользовательская функция добавлена ​​в конвейер обработки может устанавливать границы предложения, записывая Токен.is_sent_start .

По умолчанию: Использование анализа зависимостей Требуется модель

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

  импорт просторный

nlp = spacy.load ("en_core_web_sm")
doc = nlp ("Это предложение. Это другое предложение.")
для присланных документов:
    печать (отправлено. текст)
  

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

Статистический сегментатор предложений v3.0 Модель потребностей

SentenceRecognizer - это простой статистический компонент, который предоставляет только границы предложения. Наряду с тем, чтобы быть быстрее и меньше, чем парсер, его основное преимущество состоит в том, что его легче обучить потому что для этого требуются только аннотированные границы предложения, а не полные анализ зависимостей.Обученные конвейеры spaCy включают в себя как синтаксический анализатор, и обученный сегментатор предложений, который по умолчанию отключено. Если тебе нужно только границы предложения и без синтаксического анализатора, вы можете использовать , исключить или , отключить аргумент на spacy.load для загрузки конвейера без синтаксического анализатора, а затем явно включить распознаватель предложений с помощью nlp.enable_pipe .

senter vs. parser

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

  импорт просторный

nlp = spacy.load ("en_core_web_sm", exclude = ["parser"])
nlp.enable_pipe ("центр")
doc = nlp ("Это предложение. Это другое предложение.")
для присланных документов:
    печать (отправлено. текст)
  

Компонент конвейера на основе правил

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

  импорт просторный
from spacy.lang.en импорт английский

nlp = английский ()
nlp.add_pipe ("приговорщик")
doc = nlp ("Это предложение. Это другое предложение.")
для присланных документов:
    печать (отправлено. текст)
  

Пользовательская стратегия на основе правил

Если вы хотите реализовать свою собственную стратегию, которая отличается от стратегии по умолчанию основанный на правилах подход к разделению предложений, вы также можете создать настраиваемый компонент конвейера, который берет объект Doc и устанавливает токен .is_sent_start на каждом индивидуальный жетон. Если установлено значение False , токен явно помечается как , а не как . начало предложения. Если установлено значение Нет (по умолчанию), оно обрабатывается как отсутствующее значение. и все еще может быть перезаписан парсером.

Важное примечание

Чтобы предотвратить несогласованное состояние, вы можете установить границы только до документа анализируется (и doc.has_annotation ("DEP") - False ). Чтобы убедиться, что ваш компонент добавлен в нужном месте, вы можете установить перед = 'parser' или first = True при добавлении в конвейер с помощью нлп.add_pipe .

Вот пример компонента, который реализует правило предварительной обработки для разбиение на "..." токенов. Компонент добавляется перед анализатором, то есть затем используется для дальнейшего сегментирования текста. Это возможно, потому что is_sent_start только True для некоторых токенов - все остальные по-прежнему указывают None для неустановленных границ предложения. Этот подход может быть полезен, если вы хотите реализовать дополнительных правил , относящихся к вашим данным, при этом сохраняя возможность воспользоваться преимуществами сегментации предложений на основе зависимостей.

  из spacy.language import Language
импортный простор

text = "это предложение ... привет ... и еще одно предложение".

nlp = spacy.load ("en_core_web_sm")
doc = nlp (текст)
print ("До:", [отправленный текст для отправки в документах])

@ Language.component ("set_custom_boundaries")
def set_custom_boundaries (документ):
    для токена в документе [: - 1]:
        если token.text == "...":
            doc [token.i + 1] .is_sent_start = Истина
    вернуть документ

nlp.add_pipe ("set_custom_boundaries", before = "parser")
doc = nlp (текст)
print ("После:", [отправлено.текст для отправки в документах])
  

AttributeRuler управляет сопоставлениями на основе правил и исключения для всех атрибутов уровня токена. Как количество компоненты конвейера выросли со spaCy v2 до v3, обработка правил и исключений в каждом компоненте в отдельности стала непрактично, поэтому AttributeRuler предоставляет единый компонент с унифицированным формат шаблона для всех сопоставлений атрибутов токенов и исключений.

Атрибут AttributeRuler использует Matcher шаблоны для идентификации токены, а затем присваивает им предоставленные атрибуты.При необходимости Matcher Шаблоны могут включать контекст вокруг целевого токена. Например, линейка атрибутов может:

• предоставлять исключения для любых атрибутов токена
• отображать мелкозернистых тегов до крупнозернистых тегов для языков без статистические морфологизаторы (замена v2.x tag_map в языковых данных)
• маркер карты форма поверхности + мелкозернистые теги от до морфологические признаки (замена v2.x morph_rules в языковых данных)
• указывает теги для маркеров пробелов (заменяя жестко запрограммированное поведение в tagger)

В следующем примере показано, как можно указать тег и POS NNP / PROPN для фразы "The Who" , переопределив теги, предоставленные статистическим tagger и карту тегов POS.

  импорт просторный

nlp = spacy.load ("en_core_web_sm")
text = "Я видел выступление The Who. Кого вы видели?"
doc1 = nlp (текст)
печать (doc1 [2].tag_, doc1 [2] .pos_)
печать (doc1 [3] .tag_, doc1 [3] .pos_)


ruler = nlp.get_pipe ("attribute_ruler")

pattern = [[{"LOWER": "the"}, {"TEXT": "Who"}]]

attrs = {"ТЕГ": "NNP", "POS": "PROPN"}

ruler.add (шаблоны = шаблоны, attrs = attrs, index = 0)
ruler.add (шаблоны = шаблоны, attrs = attrs, index = 1)

doc2 = nlp (текст)
печать (doc2 [2] .tag_, doc2 [2] .pos_)
печать (doc2 [3] .tag_, doc2 [3] .pos_)

печать (doc2 [5] .tag_, doc2 [5] .pos_)
  

Переход с spaCy v2.x

AttributeRuler может импортировать карту тегов и преобразовывать правила в версии 2.x с помощью встроенных методов или когда компонент инициализируется перед обучением. Увидеть руководство по миграции для получения подробной информации.

Сходство определяется путем сравнения векторов слов или «вложений слов», многомерные смысловые представления слова. Векторы слов могут быть генерируется с использованием такого алгоритма, как word2vec и обычно выглядят так:

  
 banana.vector 
   array ([2.02280000e-01, -7.66180009e-02, 3.70319992e-01,
       3.28450017e-02, -4.19569999e-01, 7.20689967e-02,
      -3.74760002e-01, 5.74599989e-02, -1.24009997e-02,
       5.29489994e-01, -5.23800015e-01, -1.97710007e-01,
      -3.41470003e-01, 5.33169985e-01, -2.53309999e-02,
       1.73800007e-01, 1.67720005e-01, 8.39839995e-01,
       5.51070012e-02, 1.05470002e-01, 3.78719985e-01,
       2.42750004e-01, 1.47449998e-02, 5.59509993e-01,
       1.25210002e-01, -6.75960004e-01, 3.58420014e-01,
       
       3.66849989e-01, 2.52470002e-03, -6.40089989e-01,
      -2.97650009e-01, 7.89430022e-01, 3.31680000e-01,
      -1.19659996e + 00, -4.71559986e-02, 5.31750023e-01], dtype = float32)
  

Важное примечание

Чтобы сделать их компактными и быстрыми, небольшие конвейерные пакеты spaCy (все пакеты, заканчивающиеся на sm ) , не поставляются с векторами слов и включают только контекстно-зависимые тензоры . Это означает, что вы все еще можете использовать подобие () методы для сравнения документов, промежутков и токенов, но результат не будет таким хорошо, и отдельным токенам не будут назначены векторы.Итак, чтобы использовать реальных векторов слов, вам необходимо загрузить более крупный пакет конвейера:

  - python -m spacy загрузить en_core_web_sm
+ python -m spacy загрузить en_core_web_lg
  

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

  импорт просторный

nlp = spacy.load ("en_core_web_md")
tokens = nlp ("собака кошка банан afskfsd")

для токена в токенах:
    print (token.text, token.has_vector, token.vector_norm, token.is_oov)
  

• Текст : исходный текст токена.
• имеет вектор : Имеется ли у токена векторное представление?
• Норма вектора : Норма L2 вектора токена (квадратный корень из сумма квадратов значений)
• OOV : вне словарного запаса

Слова «собака», «кошка» и «банан» довольно распространены в английском языке, поэтому они часть словаря конвейера и поставляется с вектором.Слово «afskfsd» на другая рука гораздо менее распространена и не входит в словарный запас, поэтому ее вектор представление состоит из 300 измерений 0 , то есть практически несуществующий. Если ваше приложение получит пользу от большого словаря с больше векторов, вам следует рассмотреть возможность использования одного из более крупных пакетов конвейера или загрузка в полном векторном пакете, например, en_core_web_lg , что включает 685k уникальных Векторы .

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

Каждый Doc , Span , Token и Lexeme имеет сходство с . метод, позволяющий сравнить его с другим объектом и определить сходство.Конечно, сходство всегда субъективно - будь то два слова, или документы похожи, в действительности зависит от того, как вы на это смотрите. spaCy’s реализация подобия обычно предполагает довольно общее определение сходство.

📝 Что стоит попробовать

1. Сравните два разных токена и попытайтесь найти два наиболее разных токены в текстах с наименьшей оценкой сходства (согласно векторы).
2. Сравните сходство двух объектов Lexeme , записи в словарь.Вы можете получить лексему с помощью атрибута .lex токена. Вы должны увидеть, что результаты подобия идентичны токену сходство.

  импорт просторный

nlp = spacy.load ("en_core_web_md")
doc1 = nlp («Мне нравится соленый картофель фри и гамбургеры.»)
doc2 = nlp («Фастфуд очень вкусный.»)


print (doc1, "<->", doc2, doc1.similarity (doc2))

french_fries = doc1 [2: 4]
бургеры = doc1 [5]
print (french_fries, «<->», гамбургеры, french_fries.similarity (гамбургеры))
  

Чего ожидать от результатов схожести

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

• Объективного определения сходства не существует. «Я люблю гамбургеры» и «Я как макароны »аналогичен в зависимости от вашего приложения . Оба говорят о еде предпочтения, что делает их очень похожими, но если вы анализируете упоминания еды, эти предложения довольно не похожи, потому что они говорят о очень разные продукты.
• Сходство значений по умолчанию для объектов Doc и Span к средним векторов токенов. Это означает, что вектор для «быстрого еда »- это среднее значение векторов для слов« быстро »и« еда », что не является обязательно представитель словосочетания «фаст-фуд».
• Усреднение вектора означает, что вектор нескольких токенов нечувствителен к порядок слов. Два документа, выражающие одно и то же значение с несходная формулировка даст более низкий балл схожести, чем два документа которые содержат одни и те же слова, но имеют разные значения.

💡Совет: ознакомьтесь с sense2vec

sense2vec - это библиотека, разработанная us, который построен на основе spaCy и позволяет вам обучать и запрашивать более интересные и подробные векторы слов. Он сочетает в себе такие словосочетания, как «фаст-фуд» или «честная игра». и включает теги части речи и метки объектов. Библиотека также включает рецепты аннотаций для нашего инструмента аннотации Prodigy которые позволяют вам оценивать векторы и создавать списки терминологии. Больше подробностей, ознакомьтесь с нашим сообщением в блоге.К изучить семантическое сходство всех комментариев Reddit за 2015 и 2019 годы, см. интерактивную демонстрацию.

Добавление векторов слов

Пользовательские векторы слов можно обучить с помощью ряда библиотек с открытым исходным кодом, таких как как Gensim, FastText, или оригинал Томаша Миколова Реализация Word2vec. Большинство библиотеки векторных слов выводят удобный для чтения текстовый формат, где каждая строка состоит из слова, за которым следует его вектор. Для повседневного использования мы хотим преобразовать векторы в двоичный формат, который загружается быстрее и занимает меньше времени место на диске.Самый простой способ сделать это - векторы инициализации Утилита командной строки. Это выведет пустой конвейер spaCy в каталоге / tmp / la_vectors_wiki_lg , что дает вам доступ к некоторым красивым латинским векторам. Затем вы можете передать путь к каталогу spacy.load или используйте его в [инициализировать] вашей конфигурации, когда вы обучить модель.

Пример использования

  nlp_latin = spacy.load ("/ tmp / la_vectors_wiki_lg")
doc1 = nlp_latin ("Caecilius est in horto")
doc2 = nlp_latin ("servus est in atrio")
doc1.сходство (doc2)
  

  wget https://s3-us-west-1.amazonaws.com/fasttext-vectors/word-vectors-v2/cc.la.300.vec.gz 
 python -m spacy init vectors en cc. la.300.vec.gz / tmp / la_vectors_wiki_lg  

Как оптимизировать векторное покрытие¶

Чтобы помочь вам найти хороший баланс между покрытием и использованием памяти, spaCy's Vectors Класс позволяет сопоставить нескольких ключей с тем же строка таблицы. Если вы используете spacy init vectors команда для создания словаря, об обрезке векторов позаботится автоматически, если вы установите --prune флаг.Вы также можете сделать это вручную, выполнив следующие шаги:

1. Начните с пакета векторов слов , который охватывает огромный словарный запас. Для Например, пакет en_core_web_lg предоставляет 300-мерные векторы GloVe для 685 тыс. Терминов английского языка.
2. Если в вашем словаре есть значения, установленные для атрибута Lexeme.prob , лексемы будут отсортированы по убыванию вероятности, чтобы определить, какие векторы обрезать. В противном случае лексемы будут отсортированы по порядку в Vocab .
3. Позвоните Vocab.prune_vectors с номером векторы, которые вы хотите сохранить.

  nlp = spacy.load ("en_core_web_lg")
n_vectors = 105000
удалено_слова = nlp.vocab.prune_vectors (n_vectors)

assert len ​​(nlp.vocab.vectors) <= n_vectors
утверждать nlp.vocab.vectors.n_keys> n_vectors
  

Vocab.prune_vectors уменьшает вектор тока таблица на заданное количество уникальных записей и возвращает словарь, содержащий удаленные слова, сопоставленные с (строка, оценка) кортежа, где строка - это запись, с которой было сопоставлено удаленное слово, и балла балла сходства между два слова.

  
 Удаленные слова 
   {
    «Берег»: («берег», 0,732257),
    «Предосторожность»: («осторожность», 0,4),
    «безнадежность»: («печаль», 0,742366),
    «Непрерывный»: («Непрерывный», 0,732549),
    "Распущенный": ("труп", 0,499432),
    «биостатистик»: («ученый», 0,339724),
    "somewheres": ("somewheres", 0,402736),
    "наблюдение": ("наблюдать", 0.823096),
    «Уход»: («Уход», 1.0),
}
  

В приведенном выше примере вектор для «Берега» был удален и переназначен на вектор «берега», который оценивается примерно на 73% схожим.«Уход» был перенесен на вектор «ухода» идентичен. Если вы используете init vectors команду, вы можете установить --prune возможность легко уменьшать размер векторов при добавлении их в spaCy pipeline:

  python -m spacy init vectors en la.300d.vec.tgz / tmp / la_vectors_web_md --prune 10000  

Это создаст пустой конвейер spaCy с векторами для первых 10000 слов в векторах. Все остальные слова в векторах отображаются на ближайший вектор среди оставшихся.

Добавление векторов по отдельности

Атрибут вектор представляет собой только для чтения массив numpy или cupy (в зависимости от настроили ли вы spaCy для использования памяти графического процессора) с dtype float32 . В массив доступен только для чтения, поэтому spaCy может избежать ненужных операций копирования, где возможный. Вы можете изменить векторы через Vocab или Векторы таблица. С помощью Vocab.set_vector Метод часто самый простой подход если у вас есть векторы в произвольном формате, как вы можете читать в векторах с ваша собственная логика и просто установите их с помощью простого цикла.Этот метод может быть медленнее, чем подходы, которые работают со всей таблицей векторов сразу, но это отличный подход для разовых конверсий, прежде чем вы сэкономите свои nlp объект на диск.

  
 Добавление векторов 
   из spacy.vocab import Vocab

vector_data = {
    "собака": numpy.random.uniform (-1, 1, (300,)),
    «кошка»: numpy.random.uniform (-1, 1, (300,)),
    "оранжевый": numpy.random.uniform (-1, 1, (300,))
}
Vocab = Vocab ()
словом, вектор в vector_data.Предметы():
    voiceab.set_vector (слово, вектор)
  

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

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

  из spacy.lang.en импорт английский
из spacy.lang.de импорт немецкий

nlp_en = английский ()
nlp_de = немецкий ()
  

Создание подкласса настраиваемого языка

Если вы хотите настроить несколько компонентов языковых данных или добавить поддержку для пользовательского языка или "диалекта" домена, вы также можете реализовать свой собственный языковой подкласс.Подкласс должен определять два атрибута: lang (уникальный код языка) и Defaults , определяющие языковые данные. Для обзор доступных атрибутов, которые можно перезаписать, см. Language.Defaults документация.

  из spacy.lang.en импорт английский

класс CustomEnglishDefaults (англ.Defaults):
    stop_words = set (["заказ", "стоп"])

class CustomEnglish (английский):
    lang = "custom_en"
    По умолчанию = CustomEnglishDefaults

nlp1 = английский ()
nlp2 = CustomEnglish ()

печать (nlp1.lang, [token.is_stop для токена в nlp1 («настраиваемая остановка»)])
print (nlp2.lang, [token.is_stop для токена в nlp2 («настраиваемая остановка»)])
  

Декоратор @ spacy.registry.languages ​​ позволяет зарегистрируйте собственный языковой класс и присвойте ему строковое имя. Это значит, что Вы можете позвонить spacy.blank со своим индивидуальным название языка, и даже обучать конвейеры с ним и ссылаться на него в вашем тренировочная конфигурация.

Использование конфигурации

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

  [nlp]
lang = "custom_en"
  

Чтобы разрешить "custom_en" для вашего подкласса, зарегистрированная функция должен быть доступен во время тренировки. Вы можете загрузить файл Python, содержащий код с использованием аргумента --code :

  python -m spacy train config.cfg --code code.py  

  
 Регистрация настраиваемого языка 
   import spacy
от простора.lang.en import English

класс CustomEnglishDefaults (англ.Defaults):
    stop_words = set (["заказ", "стоп"])

@ spacy.registry.languages ​​("custom_en") класс CustomEnglish (английский):
    lang = "custom_en"
    По умолчанию = CustomEnglishDefaults

nlp = spacy.blank ("custom_en")  

Корпусная лингвистика и специализированная лексикография

1Слова не имеют значений, значения имеют слова. Это может показаться очевидным и лежит в основе соссюровского представления о арбитражном суде , но часто это далеко от нашего повседневного отношения к языку.Контекстуалистическая школа мысли, восходящая к Фёрту (1890-1960), воплощает понятие произвольности, заявляя, что значение слова может быть полностью оценено только в контексте, контекст является изначальным. Это создает серьезную проблему при написании словаря, поскольку статья всегда находится вне контекста. Таким образом, значение представляет собой проблему как для лексикографа, так и для пользователя словаря. Для лексикографа значение должно быть перенесено из контекста в словарную статью с использованием метаязыка, достаточно понятного пользователю.Для пользователя задача состоит в том, чтобы передать смысл из словаря в текст, а при письме из словаря в новый контекст.

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

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

4Словари бывают разных форм и служат не только для обучения, но и для самых разных целей. « Словарь » - действительно многозначное слово, охватывающее такие разные произведения, как исторические словари, такие как Оксфордский словарь английского языка (OED), и высокоэнциклопедические работы, такие как Оксфордский словарь биохимии и молекулярной биологии (ODBMB). Первый - классический языковой словарь, второй - более энциклопедический по своей природе и посвящен терминологии; их объединяет тенденция представлять слова как отдельные элементы в алфавитном порядке.Это семасиологическое представление может быть не лучшим, но это то, что мы привыкли ожидать от словаря. Единственными исключениями из этого алфавитного правила в нашем повседневном использовании, как правило, являются ономасиологически организованные тезаурусы, такие как тезаурус Роже.

5 Большое разнообразие типов словарей означает, что дать точное определение концепции далеко не просто, хотя мы все знаем, что мы «подразумеваем» под словарем, и можем распознать один, когда видим его. Согласно Oxford Advanced Learners Dictionary (OALD), словарь составляет:

( a ) книга, в которой слова определенного языка представлены в алфавитном порядке и объясняются их значения или переводятся на другой язык.( b ) похожая книга, в которой объясняются термины определенного предмета. (OALD)

6 Фактически, OALD дает нам три определения. И OED, и OALD попадают в категорию «а», поскольку они стремятся объяснить значения слов, в то время как ODBMD явно относится к категории «b». Категория «а», однако, делится на две части, поскольку у нас есть как одноязычные словари, как в моих примерах, так и двух- или многоязычные словари, такие как Roberts and Collins Senior (RCS).

7 Чрезвычайно широкое определение OALD оставляет много недосказанного, но, поскольку все мы «знаем», как выглядит словарь, это обычно не считается проблемой. К сожалению, как в общем, так и в металексикографическом плане могут быть скрытые проблемы. Обычные пользователи неизменно не знают, как составляются словари и к какой аудитории они обращаются. Они также имеют тенденцию к "фиксированному" отношению к значению слов, из-за чего они забывают или игнорируют эволюцию языка.Эти факторы могут побудить наших студентов полагаться на словари, которые они находят дома, будь то одно- или двуязычные, которые безнадежно устарели и которые заставляют их использовать общие языковые значения в специализированных контекстах, часто с весьма забавными результатами. Эти проблемы часто возникают из-за незнания типов словарей и их использования, что широко распространено даже среди учителей иностранных языков. Очевидно, что для лексикографа критически важно знать типологию словарей; Подробный анализ проблемы с точки зрения металексикографа можно найти в Béjoint (1994 2000), обязательное чтение для всех, кто интересуется лексикографом или преподаванием языков.Здесь нет необходимости вдаваться в подробности.

8Разница между моно- и двуязычными словарями очевидна, и хотя недостатки использования последних хорошо известны при обучении языкам, мы не будем их здесь рассматривать. Однако следует отметить, что двуязычный словарь, как и его одноязычный аналог, также претерпел революционные изменения с появлением компьютера. Сью Аткинс, один из лидеров модернизации двуязычных словарей, подробно обсудила это (Аткинс, 2002).Здесь мы имеем дело с одноязычными словарями, как общими, так и специализированными.

9 Если мы возьмем определение одноязычного словаря, данное в OALD, мы упустим важный момент. Отец английских словарей, OED, ведет свою историю от словаря Джонсона 1755 года. Это словари, которые не являются полностью предписывающими, но являются нормативными. Что наиболее важно, OED превратился в исторический словарь, посвященный показу эволюции английского языка, в основном через литературное использование.Его цели выходят далеко за рамки простого определения значений слов. С другой стороны, меньший COD является справочным изданием, но, как и большинство более коротких произведений, в значительной степени зависит от более крупного словаря, в данном случае OED. Точно так же, если мы найдем определение слова «словарь» в COD и сравним его с определением OALD, мы обнаружим, что они почти идентичны. Опять же, OALD полагается на своего старшего брата; просто начинать словарь с нуля - это слишком трудоемко и дорого. Тем не менее, хотя определения могут быть похожими, COD и OALD принципиально отличаются.COD адресован носителям языка, которые обычно обращаются к словарям, чтобы проверить написание или проверить значения слов, в которых они не уверены, поэтому он предназначен в основном для пассивного использования. Словари для учащихся, такие как OALD, изначально были предназначены для людей, не являющихся носителями языка, и стремились объединить две роли: декодирование и кодирование. Аспект декодирования - пассивный, когда учащиеся ищут непонятные слова, чтобы выяснить их значение в контексте. Аспект кодирования выходит далеко за рамки простого написания и должен позволять автору писать понятный язык, что влечет за собой предоставление примеров использования и тщательно закодированной грамматической информации.

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

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

12 Преподавание и словари всегда были неразрывно связаны, от англо-французского словаря Холибанда 1593 года до Oxford Advanced Learner's Dictionary Хорнби, впервые опубликованного в 1948 году. Историю подъема ELT рассказывает Ховатт (1984). и в нем мы видим, что прогресс в педагогической практике, особенно с середины войны, идет бок о бок с достижениями в создании словарей. Появление словаря ELT сопровождалось выбором и объяснением основного языка, необходимого для изучающего второй язык.

13 Потребность в контролируемом словарном запасе для читателей стала очевидной в 1930-х годах и привела к работе Уэста и его знаменитому списку английских слов категории общего обслуживания , опубликованному в 1953 году (Howatt 1984). Работа Хорнби вышла за рамки списков и потребностей учеников более низкого уровня в создании полноценного словаря для продвинутых учеников. Словарь Хорнби был не просто уменьшенной версией более крупного труда, а специально созданным, составленным с учетом потребностей тех, для кого не родной язык.OALD должен был содержать не только отдельные слова, но идиомы и словосочетания, плод долгого сотрудничества Хорнби с Палмером в Японии (Cowie 1998). Благодаря OALD у нас есть словарь, адаптированный к потребностям языкового производства, с объяснениями и примерами формирования слов. В более поздних изданиях использовалась грамматическая информация, выявленная в Quirk et al. , основанном на корпусе Grammar of Contemporary English (Quirk et al .1985).

14Словарь Хорнби положил начало процессу, который привел к тому, что на рынке появилось множество словарей для учащихся, которые ценятся как для продвинутых учеников, так и для носителей языка.В недавнем исследовании использования словарей пользователями второго языка в США МакКрири и Долезал (1999) обнаружили, что использование словарей учащихся приводит к гораздо лучшим результатам, чем стандартные словари американских колледжей, и что даже американская контрольная группа носителей языка принесла бы пользу. из аналогичных работ, чтобы избежать стандартных ошибок использования словарей. Затем Маккрири (2002) пошел дальше, проведя углубленное исследование студентов американских университетов, которое показало, что студенты использовали плохие стратегии использования словаря, с плохими результатами по трудному словарю.При наличии стандартных словарей колледжа и словарей учащихся было обнаружено, что пользователи последних заметно превосходят пользователей первых. Словарь учащегося ни в коем случае не должен рассматриваться исключительно для неродных пользователей.

15 В этих словарях учащихся смыслы слов выражаются откровенно контекстуалистично, слова приобретают значение только в контексте, и поэтому словарь должен стремиться показать эти контексты, показывая реальное использование. Оставалась проблема, какие слова включить в словарь.Списки слов, какими бы хорошими они ни были, они субъективны. Хорнби использовал COD в качестве основы OALD, исключив слова, которые он считал бесполезными для студентов-иностранцев. Этот выбор был основан на его интуиции и огромном опыте преподавателя языка, исследователя и лексикографа. Хотя нельзя недооценивать знания квалифицированного лексикографа, получаемый в результате выбор, как слов, так и порядка значений, неизбежно субъективен. Это препятствие можно было преодолеть с помощью компьютеров и электронных корпусов.

16Компьютеры оказали большое влияние на создание словарей, карточные файлы традиционной лексикографии исчезли в базах данных, которые позволяют легко хранить, передавать данные и, прежде всего, делать перекрестные ссылки. Использование моделей хранения на основе SGML упростило переформатирование существующих материалов, просто изменив таблицу стилей. Появление Интернета и компакт-дисков означало, что разрабатываются новые форматы, обеспечивающие быстрый доступ пользователей к данным.Несмотря на критику, что многие электронные словари являются только бумажными в электронном формате, онлайн-словари и словари на компакт-дисках предлагают много практических преимуществ по сравнению со своими бумажными аналогами. В свою очередь, вычислениям помогла лексикография в том смысле, что исследователи в области обработки естественного языка (НЛП) получили доступ к электронным материалам для анализа (Fontenelle 2002). Этот обмен, в свою очередь, будет полезен как для людей, так и для машин.

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

18 Как мы видели, до недавнего времени составление словарей полагалось на интуицию обученных лексикографов в анализе материала и написании определений. Заглавные слова были выбраны на основе предполагаемой важности, и многозначность рассматривалась таким же образом.Даже словари для учащихся со временем выросли без четких критериев включения или исключения слов. Решение COBUILD выделено жирным шрифтом; команда создала бы словарь с нуля, основываясь не на картах файлов, а на большом электронном корпусе. Следует отметить, что отныне слово корпус , множественное число корпус , будет использоваться только для обозначения больших электронных корпусов, собранных из очень большого количества аутентичного текста

 пусть doc = nlp (весь роман)
doc.match ('Прилагательное времени'). text ()
// "в самый последний момент?" 

 if (doc.has ('simon говорит #Verb') === false) {
  вернуть ноль
} 

 let doc = nlp ('она продает ракушки на берегу моря.')
doc.verbs (). toPastTense ()
doc.text ()
// «она продавала ракушки на берегу моря». 

 let doc = nlp ('фиолетовый динозавр')
doc.nouns (). toPlural ()
doc.text ()
// 'фиолетовые динозавры' 

 nlp.extend (требуется ('компромиссные числа'))

let doc = nlp ('девяносто пять тысяч пятьдесят два')
doc.numbers (). add (2)
doc.text ()
// 'девяносто пять тысяч пятьдесят четыре' 

 пусть doc = nlp (buddyHolly)
doc.people (). если ('Мэри'). json ()
// [{текст: 'Мэри Тайлер Мур'}]

пусть doc = nlp (freshPrince)
doc.places (). first (). text ()
// 'Западная Филлидельфия'

doc = nlp ('опера о визите Ричарда Никсона в Китай')
doc.topics (). json ()
// [
// {текст: 'richard nixon'},
// {текст: 'китай'}
//] 

 let doc = nlp ("мы не собираемся это принимать, нет, мы не собираемся это делать.")

// соответствие неявному термину
doc.has ('going') // правда

// преобразовываем
doc.contractions (). expand ()
dox.text ()
// 'мы не собираемся брать, нет, мы не собираемся это брать'. 

 

<сценарий>
  nlp.extend (compomiseNumbers)

  var doc = nlp ('две бутылки пива')
  номера документов (). минус (1)
  документ.body.innerHTML = doc.text ()
  // 'одна бутылка пива'
 

 импортировать nlp из "компромисса"

var doc = nlp ('Лондон звонит')
doc.verbs (). toNegative ()
// 'Лондон не звонит' 

 пусть myWords = {
  kermit: 'Имя',
  фоззи: 'Имя',
}
пусть doc = nlp (muppetText, myWords) 

 const nlp = require ('компромисс')

nlp.extend ((Док, мир) => {
  // добавляем новые теги
  world.addTags ({
    Персонаж: {
      isA: 'Человек',
      notA: 'Прилагательное',
    },
  })

  // добавляем или меняем слова в лексиконе
  Мир.addWords ({
    kermit: 'Персонаж',
    гонзо: 'Персонаж',
  })

  // добавляем методы для запуска после теггера
  world.postProcess (doc => {
    doc.match ('зажигать огни'). tag ('# Verb. #Plural')
  })

  // добавляем совершенно новый метод
  Doc.prototype.kermitVoice = function () {
    this.sentences (). prepend ('ну,')
    this.match ('я [(я | был)]'). prepend ('ммм,')
    верни это
  }
}) 

 импортировать nlp из "компромисса"
импортировать нграммы из "компромиссных"
импортировать номера из 'компромиссных номеров'

константа nlpEx = nlp.расширить (ngrams) .extend (числа)

nlpEx ('Это типобезопасный!'). ngrams ({min: 1})
nlpEx ('Это типобезопасный!'). numbers () 

 
<сценарий>
  var doc = nlp ('Нет, моего сына также зовут Борт.')

  // видно, что в тексте нет тегов
  console.log (doc.has ('# Noun')) // ложь

  // остальная часть api все еще работает
  приставка.b [oa] rt / ')) // правда