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

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

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

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

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

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

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


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

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

  

В отличие от 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 установлено, возвращает логическое значение. Если результат Ложь , предложение по умолчанию итератор вызовет исключение.

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

Для списка меток синтаксических зависимостей, назначенных моделями 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 and 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 (потомок)
    print (Потомок.текст, Потомок.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 .
• Метка: Метка объекта, т.е. тип.

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

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

Стандартный способ доступа к аннотациям сущностей - это документ .энц Свойство, которое создает последовательность из объектов 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")


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


doc.ents = список (doc.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] = док.voiceab.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_ из Span объект или атрибуты ent_kb_id и ent_kb_id_ объекта Токен объект.

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

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 (в обратном порядке (суффиксы))
    вернуть жетоны
  

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

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

Global и , зависящие от языка данные токенизатора предоставляются через язык данные на spacy / lang . Исключения токенизатора определите особые случаи, такие как «не» на английском языке, которые нужно разделить на два tokens: {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): return 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
  

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

  суффиксов = список (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
  

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

Вот пример самого простого токенизатора пробелов.Требуется общий Dictionary, поэтому он может создавать объекты 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.словарь, слова = слова, пробелы = пробелы)
печать (текст документа)
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», «casts» . Тебе следует увидеть что теперь есть два токена длины 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_ с установкой и без установки атрибутов .Вы увидите, что в лемме по умолчанию используется «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 применяются только к слову в контексте, поэтому они являются атрибутами токена. Если атрибут - это не зависящий от контекста лексический атрибут, он будет применяться к лежащая в основе Лексема , запись в словаре. Например, 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 = 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 . Для слияния, вам необходимо предоставить один словарь атрибутов для результирующего объединенный токен.Для разделения вам необходимо предоставить список словарей с настраиваемые атрибуты, по одному на каждый под токен разделения.

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

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

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

1. Добавьте еще одно собственное расширение - может быть, "music_style" ? - и перезапишите его.
2. Измените атрибут расширения, чтобы использовать только функцию получения . Вам следует видите, что spaCy вызывает ошибку, потому что атрибут недоступен для записи больше.
3. Перепишите код, чтобы разделить токен с помощью ретокенизатора .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. Пользовательская функция: ваша собственная пользовательская функция добавлена ​​в конвейер обработки может устанавливать границы предложения, записывая Token.is_sent_start .

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

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

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

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

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

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

The 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 атрибут на каждом индивидуальный жетон. Если установлено значение Ложь , токен явно помечается как , а не как . начало предложения. Если установлено значение Нет (по умолчанию), оно обрабатывается как отсутствующее значение. и все еще может быть перезаписан парсером.

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

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

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

  из 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 шаблоны могут включать контекст вокруг целевого токена. Например, линейка атрибутов может:

• предоставлять исключения для любых атрибутов токенов
• сопоставлять мелкозернистых тегов - крупнозернистых тегов для языков без статистические морфологизаторы (замена 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")

patterns = [[{"НИЖНИЙ": "the"}, {"ТЕКСТ": "Кто"}]]

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 может импортировать карту тегов и преобразовывать rules в v2.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.2
94e-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.593e-01,
       1.25210002e-01, -6.75960004e-01, 3.58420014e-01,
       
       3.66849989e-01, 2.52470002e-03, -6.40089989e-01,
      -2.97650009e-01, 7.8
22e-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 . Док. Вектор и 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 с векторами для первых 10 000 слов в векторах. Все остальные слова в векторах отображаются на ближайший вектор среди оставшихся.

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

Атрибут vector представляет собой массив только для чтения 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")  

Анализ и выполнение II

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

На любом компилируемом языке программа не работает словами (токенами) и затем анализируется, и код генерируется из проанализированного результата. Не так в J: предложение разбито на слова, но предложение не разобрано полностью; скорее, синтаксический анализ и выполнение продолжаются одновременно, просматривая текст справа налево. Анализ находок шаблоны в предложении, которые затем исполняются. Исполнение включает обычную поставку существительных операндов к глаголам для получения результата от глагол, но также и другие действия: предоставление операндов глагола и существительного союзы и наречия для создания производных сущностей, а также признание других последовательности, которые мы скоро узнаем.

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

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

Я хочу повторить, что используемое здесь слово «казнь» не синоним слова «исполнение существительных операндов». Да, глаголы так исполняются. Но выполнение модификатора создает анонимную сущность, и это может вообще не употребляйте существительные (как в примере + &.>). Выполнение модификатора - это шаг по путь к исполнению производного глагола.

Таблица синтаксического анализа

Казнь предложения начинается с разбивки предложения на слова. Слова (с маркером начала строки, показаны здесь как $, добавленные в начале) становятся исходным содержимым необработанного списка слов. Стопка с опусканием также будет использоваться во время исполнение; изначально он пуст. Исполнение предложения выполняется путем повторения шага синтаксического анализа, который включает: (1) исследование первых 4 элементы стека, чтобы проверить, соответствуют ли они одному из 9 исполняемых шаблонов; (2) если совпадение было найдено, выполнение исполняемой части стека (что мы вызвали исполняемый фрагмент в предыдущей главе), в результате слово, заменяющее фрагмент в стеке; (3) если совпадений не найдено, перемещение крайнего правого слова из необработанного списка слов в крайнее левое положение стека, сдвигая остальную часть стека вправо.Исполнение заканчивается, когда нет необработанные слова и стек не содержит исполняемого шаблона. Обратите внимание, что выполнение фрагмента может оставить стек соответствует одному из исполняемых шаблонов, поэтому несколько последовательных шаги синтаксического анализа могут выполнять выполнение без перемещения чего-либо на куча. После того, как все слова были обработанный, стек должен содержать маркер начала строки, за которым следует отдельное слово, которое становится результатом предложения.

Чтобы проследить за синтаксическим анализом, нам нужно знать, какие паттерны в вершина стека содержит исполняемый фрагмент.Таблица синтаксического анализа ниже приводится полный список. Больше, чем один символ в рамке означает, что любой из них соответствует рамке. имя означает любое допустимое имя переменной, а C, A, V и N обозначают союз, наречие, глагол и существительное соответственно.

Строки в таблице синтаксического анализа обрабатываются в приказ.Если крайние левые 4 слова на stack соответствует строке в таблице, фрагмент (те слова в стеке, которые выделены жирным шрифтом в таблице синтаксического анализа) выполняется и заменяется в стеке на единственное слово вернулось. Поскольку Фрагмент всегда состоит из двух или трех слов, он официально известен как двузубец или трезубец. Последний столбец таблицы синтаксического анализа дает описание того, что влечет за собой выполнение фрагмента.

Вам будет легче следить за парсингом, если вы обратите внимание, что крайнее левое слово в исполняемом шаблоне обычно равно $ =.=: ( A V N . Это означает, что вы можете сканировать справа пока вы не нажмете слово, которое соответствует одному из них, прежде чем вы даже начнете проверять для исполняемого шаблона. Если вы найдете один из $ =. =: ( A V N и он не соответствует исполняемому шаблону, продолжайте искать следующий вхождение.

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

Строка 6, определяющая крючки, подходит для любой комбинации CAVN CAVN , кроме N A и V A , который совпадают в строке 3. Только комбинации A A , C N , C V , N C , V C , и V V являются действительный; остальные приводят к синтаксическим ошибкам.

Примеры разбора и исполнения

Теперь рассмотрим несколько предложений с помощью синтаксического анализа. Мы будем представлять анонимные организации по именам курсивом с указанием того, как была создана анонимная сущность.До сих пор в этой книге мы почти не заметил, что термин «глагол» использовался как для сущности, которая может применяться к существительное, чтобы произвести существительное результат, а также для имени этого юридическое лицо. Эта двусмысленность продолжить - быть точным было бы слишком сложно - но вы должны знать Это. Когда мы говорим «результат ср. », определяется как + / ', это означает, что был создан анонимный глагол, функция которого описывается как + /, и прозвище, которое мы ему даем - слово, то есть то, что идет на казнь stack для обозначения этого глагола - это av .

Предложение: + / 2 * a, где a равно 1 2 3

Столбец с надписью «линия» указывает, какая строка таблица синтаксического анализа соответствовала стеку. Фрагмент выделен жирным шрифтом и подчеркнут. Обратите внимание, что когда существительное переместилось на стек, его значение было перемещено; когда именованный глагол, наречие или союз перемещается в стек, перемещается только имя . Также обратите внимание, что значение существительного (1 2 3 здесь) - это одно слово.

С этого момента мы будем опускать строки, не содержащие исполняемый фрагмент.

Предложение: среднее =: + /% #

Я хочу подчеркнуть, что то, что присвоено значению это результат синтаксического анализа + /% #.Это , а не , последовательность + /% #, а скорее один глагол, который выполняет функцию, описываемую вилка. Теперь вы понимаете, зачем ставить круглые скобки вокруг определения не имеют значения: av2 будет проанализирован то же самое в любом случае.

Предложение: среднее 4 5 6

Так как среднее - это результат синтаксического анализа + /% #, он выполнен без лишних слов.. "1)