Синтаксический разбор предложения с обращением: синтаксический разбор простого предложения осложненные обращением примеры

Чтобы гарантировать, что последовательность аннотаций токенов остается неизменной, вы должны установить аннотации сущностей на уровне документа .Однако вы не можете писать непосредственно к атрибутам 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] = док.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, см. «Схема маркировки» отдельных моделей в каталог моделей.

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

дисплей ^{визуализатор ENT} позволяет интерактивно исследовать поведение модели распознавания сущностей. Если ты При обучении модели очень полезно запускать визуализацию самостоятельно.Помогать вы делаете это, 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 с использованием этой настраиваемой базы знаний.

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

Аннотированный идентификатор базы знаний доступен либо в виде хеш-значения, либо в виде строки, используя атрибуты 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 (в обратном порядке (суффиксы))
    для совпадения в сопоставлении (special_cases, text):
        tokens.replace (совпадение, особые_случаи [совпадение])
    вернуть жетоны
  

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

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

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
перейти ТОКЕН
! СУФФИКС
"СУФФИКС
  

  from 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 По умолчанию и атрибуты токенизатора , такие как Токенизатор.суффикс_поиск доступны для записи, поэтому вы можете перезаписать их скомпилированными объектами регулярного выражения, используя измененное значение по умолчанию правила. 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.словарь, слова = слова, пробелы = пробелы)
печать (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», «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}")
  

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

• Сопоставления "один-к-одному" для первых четырех токенов идентичны, что означает они сопоставляются друг с другом.Это имеет смысл, потому что они идентичны и в ввод: "i" , "слушал" , "до" и "обама" .
• Значение 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 . Для слияния, вам нужно предоставить один словарь атрибутов для результирующего объединенный токен.Для разделения вам необходимо предоставить список словарей с настраиваемые атрибуты, по одному на каждый под токен разделения.

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

Чтобы установить атрибуты расширения во время повторной токенизации, атрибуты должны быть зарегистрировал с использованием 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) для токена в документе])
  

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

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

Для предотвращения несогласованного состояния вы можете установить границы только до документа анализируется (и doc.has_annotation ("DEP") - False ). Чтобы ваш компонент добавлен в нужном месте, вы можете установить перед = '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 использует Сопоставитель шаблонов для идентификации токены, а затем присваивает им предоставленные атрибуты.При необходимости Соответствие шаблонам может включать контекст вокруг целевого токена. Например, линейка атрибутов может:

• предоставлять исключения для любых атрибутов токена
• отображать мелкозернистые теги до крупнозернистые теги для языков без статистические морфологизаторы (замена 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 может импортировать карту тегов и преобразовывать 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.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 . Док. Вектор и 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 , Токен и Lexeme идет с . Подобие метод, позволяющий сравнить его с другим объектом и определить сходство.Конечно, сходство всегда субъективно - будь то два слова, или документы похожи, в действительности зависит от того, как вы на это смотрите. spaCy’s реализация подобия обычно предполагает довольно общее определение сходство.

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

1. Сравните два разных токена и попытайтесь найти два самых разных разных токены в текстах с наименьшей оценкой сходства (согласно векторы).
2. Сравните сходство двух объектов лексемы , записи в словарь.Вы можете получить лексему с помощью атрибута .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 слов в векторах. Все остальные слова в векторах отображаются на ближайший вектор среди оставшихся.

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

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

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

После регистрации вашего пользовательского языкового класса с помощью реестра languages ​​, вы можете сослаться на него в своей тренировочной конфигурации.Этот означает, что 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")  

грамматик в Prolog

    s (S0, S): - np (S0, S1), vp (S1, S).
    np (S0, S): - det (S0, S1), n ​​(S1, S).
    vp (S0, S): - tv (S0, S1), np (S1, S).
    vp (S0, S): - v (S0, S).
    det (S0, S): - S0 = [| S].det (S0, S): - S0 = [a | S].
    det (S0, S): - S0 = [каждые | S].
    n (S0, S): - S0 = [человек | S].
    n (S0, S): - S0 = [женщина | S].
    n (S0, S): - S0 = [парк | S].
    tv (S0, S): - S0 = [любит | S].
    tv (S0, S): - S0 = [лайки | S].
    v (S0, S): - S0 = [прогулки | S].
 

% xsb
XSB версии 1.4.1 (94/11/21)
[последовательный, одно слово, оптимальный режим]
| ? - [грамматика].[Компиляция ./grammar]
[грамматика скомпилирована, время ЦП: 1,14 секунды]
[грамматика загружена]

да
| ? - s ([a, мужчина, любит, the, женщина], []).

да
| ? - s ([каждый, женщина, ходит], []).

да
| ? - s ([a, женщина, любит, the, park], []).

да
| ? - s ([a, женщина, любит, the, prak], []).

нет
| ? -
 

    с -> нп, вп.
    нп -> дет, н.
    вп -> тв, нп.
    vp -> v.
    det -> [the].
    det -> [а].
    det -> [каждые].
    п -> [мужчина].
    п -> [женщина].
    п -> [парк].
    телевизор -> [любит].
    тв -> [лайки].
    v -> [ходит].
 

    'C' ([Слово | Строка], Слово, Строка).
 

выражение -> срок, доп.
addterm -> [].
addterm -> [+], expr.
срок -> фактор, многофакторность.
мультифактор -> [].
multfactor -> [*], срок.
фактор -> [I], {целое (I)}.
фактор -> ['('], expr, [')'].
 

% xsb
XSB версии 1.4.1 (94/11/21)
[последовательный, одно слово, оптимальный режим]
| ? - [грамматика].
[Компиляция ./grammar]
[грамматика скомпилирована, время ЦП: 1,309 секунды]
[грамматика загружена]

да
| ? - expr ([4, *, 5, +, 1], []).

да
| ? - expr ([1, +, 3, *, '(', 2, +, 4, ')'], []).

да
| ? - expr ([4,5, *], []).нет
| ? -