Разбор сущ: Морфологический разбор имён существительных онлайн

  импортное пространство

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


ents = [(e.text, e.start_char, e.end_char, e.label_) для e в doc.ents]
печать (энты)


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

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

nlp = spacy.load ("en_core_web_sm")
doc = nlp("FB нанимает нового вице-президента по глобальной политике")
ents = [(e.text, e.start_char, e.end_char, e.label_) для e в doc.ents]
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 в doc.ents]
print('После', энц)

  

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

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

nlp = spacy.load ("en_core_web_sm")
doc = nlp.make_doc("Лондон — большой город в Великобритании.")
печать("До", док.энц)

заголовок = [ENT_IOB, ENT_TYPE]
attr_array = numpy.zeros((len(doc), len(header)), dtype="uint64")
attr_array[0, 0] = 3
attr_array[0, 1] = док.словарь.strings["GPE"]
doc.from_array (заголовок, attr_array)
печать("После", док.энц)
  

 
из 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
  

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

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

nlp = spacy.load ("en_core_web_sm")
документ = нлп (текст)
displacy.serve(doc,)
  

  импортное пространство

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


ents = [(e.text, e.label_, e.kb_id_) для e в doc.ents]
печать (энты)


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

  import spacy

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

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

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

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

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

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

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

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

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

Глобальные и специфичные для языка данные токенизатора предоставляются через язык данные в spacy/lang . Исключения токенизатора определить особые случаи, такие как «не» в английском языке, которые необходимо разделить на два токены: {ИЛИ: "делать"} и {ИЛИ: "не", НОРМ: "не"} . Префиксы, суффиксы а инфиксы в основном определяют правила пунктуации — например, когда отделяться точки (в конце предложения) и когда оставлять лексемы, содержащие точки неповрежденными (аббревиатуры типа «U.С.»).

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

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

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

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

  import spacy
из spacy.symbols импортировать ORTH

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


special_case = [{ORTH: "гим"}, {ORTH: "я"}]
НЛП.tokenizer.add_special_case("дай мне", special_case)


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

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

  утверждать «дай мне» не в [w.text для w в nlp («дай мне!»)]
утверждать «дай мне» не в [w.text для w в nlp ('("... дай мне...?")')]

nlp.tokenizer.add_special_case("...дай мне...?", [{"ORTH": "...дай мне...?"}])
утверждать len(nlp("...дай мне...?")) == 1
  

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

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

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

  "ПРЕФИКС
Пусть SPECIAL-1
SPECIAL-2
идти ТОКЕН
! СУФФИКС
СУФФИКС
  

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

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

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

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

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

Обычно вам не нужно создавать подкласс Tokenizer . Стандартное использование использовать re.compile() для создания объекта регулярного выражения и передать его .search() и .finditer() методы:

  импорт повторно
импортировать просторный
от простора.https?://''')

определение custom_tokenizer (nlp):
    return Tokenizer (nlp.vocab, rules=special_cases,
                                prefix_search=prefix_re.search,
                                suffix_search=suffix_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("привет-мир.  .Точно так же суффиксные правила должны
применяться только к  концу токена  , поэтому ваше выражение должно заканчиваться символом
  $  . 
  
 Изменение существующих наборов правил 
  
 Во многих случаях вам не обязательно нужны полностью настраиваемые правила. Иногда
вы просто хотите добавить еще один символ к префиксам, суффиксам или инфиксам. То
правила префикса, суффикса и инфикса по умолчанию доступны через объект  nlp 
  Значения по умолчанию  и  атрибуты Tokenizer , такие как
  Токенизатор.suffix_search  доступны для записи, поэтому вы можете
перезаписать их скомпилированными объектами регулярных выражений, используя измененное значение по умолчанию
правила. spaCy поставляется с служебными функциями, которые помогут вам скомпилировать обычный
выражения – например,
  compile_suffix_regex  : 
 
  суффиксов = nlp.Defaults.suffixes + [r'''-+$''',]
suffix_regex = spacy.util.compile_suffix_regex (суффиксы)
nlp.tokenizer.suffix_search = suffix_regex.search
  
 
 Аналогичным образом можно удалить символ из суффиксов по умолчанию: 
 
  suffixes = list(nlp.Суффиксы по умолчанию)
суффиксы.удалить("\\[")
suffix_regex = spacy.util.compile_suffix_regex (суффиксы)
nlp.tokenizer.suffix_search = suffix_regex.search
  
 
 Атрибут  Tokenizer.suffix_search  должен быть функцией, которая принимает
unicode и возвращает объект соответствия регулярному выражению   или  None  . Обычно мы используем
атрибут  .search  скомпилированного объекта регулярного выражения, но вы можете использовать некоторые другие
функция, которая ведет себя так же. 
  
 Важное примечание 
  
 Если вы загрузили обученный конвейер, запись в
  нлп.По умолчанию  или  английский. По умолчанию  напрямую не будет
работать, так как регулярные выражения считываются из данных конвейера и будут
компилируется при загрузке. Если вы измените  nlp.Defaults  , вы увидите только
эффект, если вы позвоните по номеру  spacy.blank  . Если вы хотите
изменить токенизатор, загруженный из обученного конвейера, вы должны изменить
  nlp.tokenizer  напрямую. Если вы тренируете собственный конвейер, вы можете зарегистрироваться
обратные вызовы для изменения  nlp 
объект перед тренировкой.
 
 Наборы правил префикса, инфикса и суффикса включают не только отдельные символы
но и подробные регулярные выражения, учитывающие окружающий контекст.
учетная запись. Например, существует регулярное выражение, обрабатывающее дефис между
буквы в качестве инфикса. Если вы не хотите, чтобы токенизатор разбивался на дефисы
между буквами вы можете изменить существующее определение инфикса из
  язык/пунктуация.py  : 
 
  импортировать пробел
из 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 в документе])
  
 
 Обзор регулярных выражений по умолчанию см.
  язык/пунктуация.ру  и
специфические для языка определения, такие как
  lang/de/punctuation.py  для
Немецкий. 
  
 Подключение пользовательского токенизатора к конвейеру 
  
 Токенизатор — это первый и единственный компонент конвейера обработки
это нельзя заменить записью в  nlp.pipeline  . Это потому, что он имеет
отличается от всех остальных компонентов: он принимает текст и возвращает
  Doc  , в то время как все остальные компоненты ожидают уже получить
токенизированный  Doc  .
 
 Чтобы перезаписать существующий токенизатор, необходимо заменить  nlp.tokenizer  на
пользовательская функция, которая принимает текст и возвращает  Doc  . 
  
 Создание объекта Doc 
  
 Для создания объекта  Doc  вручную требуется не менее двух
аргументы: общий  Vocab  и список слов. По желанию можно пройти
список из  пробелов  значений, указывающих, является ли токен в этой позиции
с последующим пробелом (по умолчанию  True  ).См. раздел о
предварительно размеченный текст для получения дополнительной информации. 
 
  слов = ["Пусть", "с", "идти", "!"]
пробелы = [Ложь, Истина, Ложь, Ложь]
документ = документ (nlp.vocab, слова = слова, пробелы = пробелы)
  
 
  nlp = spacy.blank("en")
nlp.tokenizer = мой_токенизатор
  
 7 9  Text 2
 
 
 
 Аргумент 
 
 Тип 
 
 Описание 
 
 
 
   
   
  STR  
 Сырой текст для токена. 
 
 
 
 
 Пример 1. Базовый токенизатор пробелов 
 
 Вот пример самого простого токенизатора пробелов.Это занимает общее
vocab, поэтому он может создавать  объектов Doc . Когда он вызывается для текста, он возвращает
объект  Doc , состоящий из текста, разделенного на один пробел. Мы можем
затем перезапишите атрибут  nlp.tokenizer  экземпляром нашего пользовательского
токенизатор. 
 
  импортное пространство
из документа импорта spacy.tokens

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

    def __call__(я, текст):
        слова = текст.расколоть(" ")
        пробелы = [Истина] * длина (слова)
        
        для i слово в перечислении (слова):
            если слово == "":
                слова [я] = " "
                пробелы [i] = Ложь
        
        если слова[-1] == " ":
            слова = слова[0:-1]
            пробелы = пробелы[0:-1]
        еще:
           пробелы[-1] = Ложь
            
        вернуть документ (self.vocab, слова = слова, пробелы = пробелы)

nlp = spacy.blank("en")
nlp.tokenizer = WhitespaceTokenizer(nlp.vocab)
doc = nlp("Что со мной случилось? - подумал он.Это был не сон».)
print([token.text для токена в документе])
  
 
 Пример 2: Сторонние токенизаторы (элементы слов BERT) 
 
 Вы можете использовать тот же подход для подключения любых других сторонних токенизаторов. Твой
пользовательскому вызываемому объекту просто нужно вернуть объект  Doc  с токенами, созданными
ваш токенизатор. В этом примере оболочка использует фрагмент слова  BERT.
токенизатор , предоставленный
 токенизаторов  библиотека. Токены
доступные в объекте  Doc , возвращенном spaCy, теперь соответствуют точным фрагментам слов
производится токенизатором.
 
 💡 Совет: spacy-transformers 
 
 Если вы работаете с моделями-трансформерами, такими как BERT, ознакомьтесь с
 космические трансформеры 
пакет расширения и документация. Это
включает конвейерный компонент для использования предварительно обученных трансформаторных весов и
 обучающие модели трансформеров  в spaCy, а так же полезные утилиты для
согласование частей слов с лингвистической токенизацией. 
 
  
 Пользовательский токенизатор частей слова BERT 
   из импорта токенизаторов BertWordPieceTokenizer
от простора.импорт токенов Doc
импортировать просторный

класс BertTokenizer:
    def __init__(self, vocab, vocab_file, нижний регистр = True):
        self.vocab = словарный запас
        self._tokenizer = BertWordPieceTokenizer (vocab_file, нижний регистр = нижний регистр)

    def __call__(я, текст):
        токены = self._tokenizer.encode(текст)
        слова = []
        пробелы = []
        для i, (текст, (начало, конец)) в enumerate(zip(tokens.tokens, tokens.offsets)):
            слова.добавлять(текст)
            если я < len(токены.токены) - 1:
                
                next_start, next_end = токены.смещения[я + 1]
                space.append (следующее_начало > конец)
            еще:
                space.append(Истина)
        вернуть документ (self.vocab, слова = слова, пробелы = пробелы)

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



  
 
 Важное примечание о токенизации и моделях 
 
 Имейте в виду, что результаты ваших моделей могут быть менее точными, если токенизация
во время обучения отличается от токенизации во время выполнения.Итак, если вы измените
Токенизация обученного конвейера впоследствии может привести к очень разным результатам.
предсказания. Поэтому вам следует обучать свой конвейер с помощью того же .
токенизатор , который он будет использовать во время выполнения. См. документы на
обучение с пользовательской токенизацией для получения подробной информации. 
 
 Обучение с пользовательской токенизацией v3.0 
 
 Конфигурация обучения spaCy описывает настройки,
гиперпараметры, конвейер и токенизатор, используемые для построения и обучения
трубопровод. Блок  [nlp.tokenizer]  относится к зарегистрированной функции  , которая
принимает объект  nlp  и возвращает токенизатор.Здесь мы регистрируем
функция с именем  whitespace_tokenizer  в
 реестр @tokenizers . Чтобы убедиться, что spaCy знает, как
создать свой токенизатор во время обучения, вы можете передать свой файл Python,
установка  --code functions.py  при запуске  spacy train  . 
 
 config.cfg 
 
  [nlp.tokenizer]
@tokenizers = "whitespace_tokenizer"
  
 
  
 functions.py 
   @spacy.registry.tokenizers("whitespace_tokenizer")def create_whitespace_tokenizer():
    защита create_tokenizer (nlp):
        вернуть WhitespaceTokenizer (nlp.словарный запас)

    вернуть create_tokenizer
  
 
 Зарегистрированные функции также могут принимать аргументы, которые затем передаются из
конфиг. Это позволяет быстро изменять и отслеживать различные настройки.
Здесь зарегистрированная функция с именем  bert_word_piece_tokenizer  занимает два
аргументы: путь к файлу словаря и следует ли переводить текст в нижний регистр. То
Подсказки типа Python  str  и  bool  гарантируют, что полученные значения имеют
правильный тип. 
 
 конфиг.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):
    защита create_tokenizer (nlp):
        вернуть BertWordPieceTokenizer (nlp.vocab, vocab_file, нижний регистр)

    вернуть create_tokenizer
  
 
 Чтобы избежать жесткого указания локальных путей в вашем файле конфигурации, вы также можете установить
vocab в интерфейсе командной строки с помощью параметра  --nlp.tokenizer.vocab_file  переопределяет при запуске
 космический поезд  . Дополнительные сведения об использовании зарегистрированных функций см.
см. документы в обучении с пользовательским кодом. 
 
 Помните, что зарегистрированная функция всегда должна быть функцией, которую spaCy
 призывает создать что-то  , а не само «что-то». В данном случае это
 создает функцию , которая принимает объект  nlp  и возвращает вызываемый объект, который
принимает текст и возвращает  Doc  . 
 
 Использование предварительно размеченного текста 
 
 spaCy обычно по умолчанию предполагает, что ваши данные представляют собой  необработанный текст  .Однако,
иногда ваши данные частично аннотируются, например. с уже существующей токенизацией,
теги частей речи и т. д. Наиболее распространенная ситуация, когда у вас есть
 предопределенная токенизация  . Если у вас есть список строк, вы можете создать
 Объект Doc  напрямую. При желании вы также можете указать список
логические значения, указывающие, следует ли за каждым словом пробел. 
 
 ✏️ Что попробовать 
 
 
 Измените логическое значение в списке из  пробелов  .Вы должны увидеть его отражение
в  doc.text  и следует ли за токеном пробел. 
 
 Удалить  пробелов=пробелов  из документа   . Вы должны увидеть, что каждый токен
теперь следует пробел. 
 
 Скопируйте и вставьте случайное предложение из Интернета и вручную создайте
 Doc  с  словами  и  пробелами , чтобы  doc.text  соответствовал оригиналу
ввод текста. 
 
 
  импортное пространство
от простора.импорт токенов Doc

nlp = spacy.blank("en")
слова = ["Привет", ",", "мир", "!"]
пробелы = [Ложь, Истина, Ложь, Ложь]
документ = документ (nlp.vocab, слова = слова, пробелы = пробелы)
печать(док.текст)
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 является неразрушающей и использует правила для конкретного языка
оптимизирован для совместимости с аннотациями банка деревьев. Другие инструменты и ресурсы
иногда может обозначать вещи по-разному — например,  «Я»  →
 ["И", "'", "м"]  вместо  ["И", "м"]  .
 
 В подобных ситуациях часто требуется настроить токенизацию так, чтобы
может объединять аннотации из разных источников вместе или брать предсказанные векторы
по
предварительно обученная модель BERT и
применить их к токенам spaCy. SpaCy’s  Выравнивание 
объект позволяет взаимно однозначно отображать индексы токенов в обоих направлениях, как
а также принимая во внимание индексы, в которых несколько токенов выравниваются с одним единственным
токен. 
 
 ✏️ Что попробовать 
 
 
 Измените заглавные буквы в одном из списков токенов – например,
 "Обама"  до  "Обама"  .Вы увидите, что выравнивание нечувствительно к регистру. 
 
 Изменить  "подкасты"  в  other_tokens  на  "pod", "casts"  . Тебе следует увидеть
что теперь есть две лексемы длины 2 в  y2x  , одна из которых соответствует
«s», а один — «подкасты». 
 
 Сделать  other_tokens  и  spacy_tokens  идентичными. Вы увидите, что все
жетоны теперь соответствуют 1-к-1. 
 
 
  из импорта spacy.training Выравнивание

other_tokens = ["i", "слушал", "to", "obama", "'", "s", "подкасты", "."]
spacy_tokens = ["i", "слушаю", "to", "obama", "s", "подкасты", "."]
align = Alignment.from_strings(other_tokens, spacy_tokens)
print(f"a -> b, длины: {align.x2y.lengths}")
print(f"a -> b, сопоставление: {align.x2y.dataXd}")
print(f"b -> a, длины: {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 
( "с" ).
 
 
 Важное примечание 
 
 Текущая реализация алгоритма выравнивания предполагает, что оба
токенизации составляют одну и ту же строку. Например, вы сможете выровнять
 ["I", "'", "m"]  и  ["I", "'m"]  , которые в сумме дают  "I'm"  , но не
 ["Я", "м"]  и  ["Я", "есть"]  . 
 
 Менеджер контекста  Doc.retokenize  позволяет объединять и
разделить токены. Все модификации токенизации хранятся и выполняются на
один раз при выходе из менеджера контекста.Чтобы объединить несколько токенов в один
токен, передать  Span  в  retokenizer.merge  . Ан
дополнительный словарь  attrs  позволяет установить атрибуты, которые будут назначены
объединенный токен — например, лемма, тег части речи или тип сущности. К
по умолчанию объединенный токен получит те же атрибуты, что и объединенный диапазон
корень. 
 
 ✏️ Что стоит попробовать 
 
 
 Проверить атрибут  token.lemma_  с настройкой  attrs  и без нее.Вы увидите, что лемма по умолчанию имеет значение «Новая», лемма корня диапазона. 
 
 Перезаписать другие атрибуты, такие как  "ENT_TYPE"  . Поскольку «Нью-Йорк» также
признана именованной организацией, это изменение также будет отражено в
 документов  . 
 
 
  импортное пространство

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

с doc.retokenize() в качестве ретокенизатора:
    retokenizer.merge(doc[3:5], attrs={"LEMMA": "Нью-Йорк"})
print("После:", [токен.текст для токена в документе])
  
 
 Совет: объединение сущностей и именных словосочетаний 
 
 Если вам нужно объединить именованные сущности или фрагменты существительных, воспользуйтесь встроенным
 merge_entities  и
 merge_noun_chunks  конвейер
компоненты. При добавлении в ваш конвейер с использованием  nlp.add_pipe  они возьмут
позаботьтесь об автоматическом объединении диапазонов. 
 
 Если атрибут в  attrs  является контекстно-зависимым атрибутом маркера, он будет
применяться к базовому токену   .Например  ЛЕММА  ,  POS 
или  DEP  применяются только к слову в контексте, поэтому они являются атрибутами токена. Если
атрибут является контекстно-независимым лексическим атрибутом, он будет применяться к
лежащий в основе  лексема  , запись в словаре. Например,
 LOWER  или  IS_STOP  применяются ко всем словам с одинаковым написанием, независимо от
контекст. 
 
 Примечание по объединению перекрывающихся отрезков 
 
 Если вы пытаетесь объединить перекрывающиеся отрезки, spaCy выдаст ошибку, потому что
непонятно, как должен выглядеть результат.В зависимости от приложения вы можете
хотите найти самый короткий или самый длинный возможный диапазон, поэтому вам решать, как отфильтровать
их. Если вы ищете самый длинный непересекающийся отрезок, вы можете использовать
 util.filter_spans  помощник: 
 
  doc = nlp ("Я живу в Берлине, Кройцберг")
пролеты = [документ[3:5], документ[3:4], документ[4:5]]
filtered_spans = filter_spans (промежутки)
  
 
 Разделение токенов 
 
 Метод  retokenizer.split  позволяет производить разделение
один токен на два или более токенов.Это может быть полезно для случаев, когда
Одних правил токенизации недостаточно. Например, вы можете разделить
«его» в лексемы «это» и «есть» - но не притяжательное местоимение «его». Ты
может написать логику на основе правил, которая может найти только правильное «свое» для разделения, но
на этот раз документ  Doc  уже будет токенизирован. 
 
 Этот процесс разделения токена требует дополнительных настроек, потому что вам нужно
укажите текст отдельных токенов, необязательные атрибуты для каждого токена и способ
токены должны быть присоединены к существующему синтаксическому дереву.Это можно сделать с помощью
предоставление списка из  головок  — либо токен для прикрепления вновь разделенного токена
to или кортеж  (токен, субтокен) , если должен быть присоединен вновь разделенный токен
к другому подтокену. В этом случае «Новый» должен быть присоединен к «Йорку» (т.
второй разделенный подтокен), а «York» должен быть присоединен к «in». 
 
 ✏️ Что попробовать 
 
 
 Назначьте субтокенам разные атрибуты и сравните результат. 
 
 Поменяйте головки так, чтобы к "in" было присоединено "New", а к "York" присоединено
на «Новый».
 
 Разбить токен на три токена вместо двух — например,
 ["Новый", "Йо", "рк"]  . 
 
 
  импортное пространство
от смещения импорта

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

с doc.retokenize() в качестве ретокенизатора:
    головы = [(док[3], 1), документ[2]]
    attrs = {"POS": ["PROPN", "PROPN"], "DEP": ["pobj", "compound"]}
    retokenizer.split(doc[3], ["Новый", "Йорк"], head=heads, attrs=attrs)
print("После:", [токен.текст для токена в документе])
displacy.render(док)
  
 
 Указание головок в виде списка  токенов  или  (токен, субтокен)  кортежей позволяет
присоединение разделенных субтокенов к другим субтокенам без необходимости отслеживать
индексы токенов после разделения. 
   "New"  "
 
 
 
 
 
 
 Токен 
 
 
 
 Описание 
 
 
 
   
   
  
2 
  
 
 Прикрепите этот токен ко второму подтексту (индекс  1 ) что  doc[3]  будет разбит на, т.е.е. «Йорк». 
 
 
 
  "Йорк"  
 
  doc[2]  
 
 Прикрепите этот токен к  doc[1]  в исходном  Doc  “in ”, т.е. 
 
 
 
 
 Если вы не заботитесь о головках (например, если вы используете только
токенизатор, а не парсер), вы можете прикрепить каждый субтокен к самому себе: 
 
  doc = nlp("Я живу в NewYorkCity")
с doc.retokenize() в качестве ретокенизатора:
    heads = [(doc[3], 0), (doc[3], 1), (doc[3], 2)] ретокенизатор.split(doc[3], ["Новый", "Йорк", "Город"], головы=головы)
  
 
 Важное примечание 
 
 При разделении токенов тексты подтокенов всегда должны соответствовать оригиналу
текст токена — или, другими словами,  "".join(subtokens) == token.text  всегда нужен
придерживаться истины. Если бы это было не так, разделение токенов могло бы легко закончиться
приводя к запутанным и неожиданным результатам, которые противоречили бы spaCy.
неразрушающая политика токенизации. 
 
  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 
метод, и они должны быть  перезаписываемыми  . Это означает, что они должны либо иметь
значение по умолчанию, которое может быть перезаписано, или геттер  и сеттер . Метод
расширения или расширения только с геттером вычисляются динамически, поэтому их
значения не могут быть перезаписаны.Для получения более подробной информации см.
документы атрибута расширения. 
 
 ✏️ Что попробовать 
 
 
 Добавьте еще одно пользовательское расширение – например,  "music_style"  ? - и перезаписать. 
 
 Измените атрибут расширения, чтобы использовать только функцию получения  . Вам следует
видите, что spaCy выдает ошибку, потому что атрибут недоступен для записи
больше. 
 
 Перепишите код для разделения токена с помощью  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(doc[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("Это предложение. Это другое предложение.")
утверждать doc.has_annotation("SENT_START")
для отправки в док.отправляет:
    печать (отправленный.текст)
  
 
 spaCy предоставляет четыре варианта сегментации предложений: 
 
 
 Парсер зависимостей: статистический
 DependencyParser  обеспечивает наиболее точную
границы предложений, основанные на анализе полных зависимостей. 
 
 Сегментатор статистических предложений: статистический
 SentenceRecognizer  проще и быстрее
альтернатива синтаксическому анализатору, который только устанавливает границы предложений. 
 
 Компонент конвейера на основе правил:
 Sentencizer  устанавливает границы предложений, используя
настраиваемый список знаков препинания в конце предложения.
 
 Пользовательская функция: ваша собственная пользовательская функция добавлена ​​в
конвейер обработки может устанавливать границы предложения, записывая в
 Токен.is_sent_start  . 
 
 
 По умолчанию: Использование анализа зависимостей Требует модели 
 
 В отличие от других библиотек, spaCy использует анализ зависимостей для определения предложения
границы. Обычно это наиболее точный подход, но он требует
 обученный конвейер , обеспечивающий точные прогнозы. Если ваши тексты
ближе к новостям общего назначения или веб-тексту, это должно хорошо работать из коробки
с обученными пайплайнами, предоставленными spaCy.Для социальных сетей или разговорного текста
которые не следуют тем же правилам, ваше приложение может извлечь выгоду из пользовательского
обученный или основанный на правилах компонент. 
 
  импортное пространство

nlp = spacy.load ("en_core_web_sm")
doc = nlp("Это предложение. Это другое предложение.")
для отправленных в doc.sents:
    печать (отправленный.текст)
  
 
 Парсер зависимостей spaCy учитывает уже установленные границы, поэтому вы можете выполнять предварительную обработку
ваш  Doc  с использованием пользовательских компонентов  до  его анализа.В зависимости от вашего текста,
это также может повысить точность синтаксического анализа, поскольку синтаксический анализатор ограничен предсказанием
анализирует в соответствии с границами предложения. 
 
 Статистический сегментатор предложений v3.0 Модель потребностей 
 
  SentenceRecognizer  представляет собой простой статистический
компонент, который только обеспечивает границы предложения. Наряду с тем, что он быстрее и
меньше парсера, его основное преимущество в том, что его легче обучать
потому что для этого требуются только аннотированные границы предложений, а не полные
разбор зависимостей.Обученные пайплайны spaCy включают в себя парсер
и обученный сегментатор предложений, который
отключен по умолчанию. Если вам нужно только
границ предложения и без синтаксического анализатора, вы можете использовать  исключить  или  отключить 
аргумент  spacy.load  для загрузки конвейера
без синтаксического анализатора, а затем явно включить распознаватель предложений с помощью
 нлп.enable_pipe  . 
 отправитель 
 против синтаксического анализатора 
 
 Отзыв для отправителя   обычно немного ниже, чем для синтаксического анализатора,
который лучше предсказывает границы предложения, когда пунктуация не
настоящее время.
 
  импортное пространство

nlp = spacy.load("en_core_web_sm", exclude=["парсер"])
nlp.enable_pipe ("отправитель")
doc = nlp("Это предложение. Это другое предложение.")
для отправленных в doc.sents:
    печать (отправленный.текст)
  
 
 Компонент конвейера на основе правил 
 
 Компонент  Sentencizer  является
компонент конвейера, который разбивает предложения на
знаки препинания вроде  .  ,  !  или ?  . Вы можете подключить его к своему конвейеру, если только
нужны границы предложения без анализа зависимостей.
 
  импортное пространство
импорт английского языка из spacy.lang.en

нлп = английский ()
nlp.add_pipe ("сентенситор")
doc = nlp("Это предложение. Это другое предложение.")
для отправленных в doc.sents:
    печать (отправленный.текст)
  
 
 Пользовательская стратегия на основе правил 
 
 Если вы хотите реализовать собственную стратегию, отличную от стратегии по умолчанию
основанный на правилах подход к разбиению на предложения, вы также можете создать
настраиваемый компонент конвейера, который
принимает объект  Doc  и устанавливает токен .атрибут is_sent_start  на каждом
индивидуальный токен. Если установлено значение  False  , токен явно помечается как , а не .
начало предложения. Если установлено значение  Нет  (по умолчанию), оно рассматривается как отсутствующее значение.
и все еще может быть перезаписан синтаксическим анализатором. 
 
 Важное примечание 
 
 Во избежание несогласованного состояния можно установить границы  только перед  документом.
анализируется (и  doc.has_annotation("DEP")  равно  False  ). Чтобы убедиться, что ваш
компонент добавлен в нужном месте, вы можете установить  перед = 'parser'  или
 first = True  при добавлении в конвейер с помощью
 нлп.add_pipe  . 
 
 Вот пример компонента, реализующего правило предварительной обработки для
разбиение на  "..."  токенов. Компонент добавляется перед парсером, т.е.
затем используется для дальнейшего сегментирования текста. Это возможно, потому что  is_sent_start 
только для некоторых токенов установлено значение  True  — все остальные по-прежнему указывают  None 
для неустановленных границ предложения. Этот подход может быть полезен, если вы хотите
внедрить  дополнительных  правил, специфичных для ваших данных, при этом сохраняя возможность
воспользоваться сегментацией предложений на основе зависимостей.
 
  из импорта spacy.language Язык
импортировать просторный

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

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

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

nlp.add_pipe («set_custom_boundaries», перед = «парсер»)
документ = нлп (текст)
print("После:", [отправлено.текст для отправки в doc.sents])
  
 
  AttributeRuler  управляет сопоставлениями на основе правил  и
исключения  для всех атрибутов уровня токена. По количеству
компоненты конвейера выросли с spaCy v2 до
v3, обработка правил и исключений в каждом компоненте по отдельности стала
непрактично, поэтому  AttributeRuler  представляет собой единый компонент с унифицированным
формат шаблона для всех сопоставлений и исключений атрибутов токена. 
 
  AttributeRuler  использует
 Matcher  шаблонов для идентификации
токены, а затем присваивает им предоставленные атрибуты.При необходимости
Шаблоны  Matcher  могут включать контекст вокруг целевого токена.
Например, линейка атрибутов может: 
 
 
 предоставлять исключения для любых  атрибутов токена  
 
 отображать  детализированные теги
статистические морфологизаторы (замена v2.x  tag_map  в
языковые данные) 
 
 токен карты  форма поверхности + мелкозернистые теги от  до  морфологические особенности 
(заменив v2.x  morph_rules  в языковых данных) 
 
 указать теги  для пробельных токенов  (заменив жестко запрограммированное поведение в
tagger) 
 
 
 В следующем примере показано, как можно указать тег и POS  NNP  /  PROPN .
для фразы  "The Who"  , переопределяя теги, предоставленные статистическим
tagger и карту POS-тегов. 
 
  импортное пространство

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


линейка = nlp.get_pipe("attribute_ruler")

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

attrs = {"TAG": "NNP", "POS": "PROPN"}

правитель.добавить (шаблоны = шаблоны, attrs = attrs, индекс = 0)
правитель.добавить (шаблоны = шаблоны, attrs = attrs, индекс = 1)

документ2 = нлп (текст)
печать (doc2[2].tag_, doc2[2].pos_)
печать (doc2[3].tag_, doc2[3].pos_)

печать (doc2[5].tag_, doc2[5].pos_)
  
 
 Миграция с spaCy v2.x 
 
  AttributeRuler  может импортировать карту тегов  и преобразование
правила  в v2.x через его встроенные методы или когда компонент
инициализируется перед тренировкой. См.
руководство по миграции для получения подробной информации. 
 
 Сходство определяется путем сравнения  векторов слов  или «вложений слов»,
многомерные смысловые представления слова. Векторы слов могут быть
генерируется по такому алгоритму
word2vec и обычно выглядят так: 
 
  
 банан.вектор 
   массив([2.02280000e-01, -7.66180009e-02, 3.70319992e-01,
       3.28450017э-02,-4.19569999э-01, 7.20689967э-02,
      -3.74760002э-01, 5.74599989э-02, -1.24009997э-02,
       5.29489994э-01, -5.23800015э-01, -1.97710007э-01,
      -3.41470003э-01, 5.33169985э-01, -2.53309999э-02,
       1.73800007э-01, 1.67720005э-01, 8.39839995э-01,
       5.51070012э-02, 1.05470002э-01, 3.78719985э-01,
       2.42750004э-01, 1.47449998э-02, 5.59509993э-01,
       1.25210002э-01, -6.75960004э-01, 3.58420014э-01,
       
       3.66849989э-01, 2.52470002э-03, -6.40089989э-01,
      -2.97650009э-01, 7.89430022э-01, 3.31680000э-01,
      -1.19659996e+00, -4.71559986e-02, 5.31750023e-01], dtype=float32)
  
 
 Важное примечание 
 
 Чтобы сделать их компактными и быстрыми, небольшие пакеты пайплайнов spaCy (все
пакеты, которые заканчиваются на  sm  )  не поставляются с векторами слов  и включают только
контекстно-зависимые  тензоры  . Это означает, что вы все еще можете использовать  подобие () 
методы сравнения документов, спанов и токенов — но результат будет не таким
хорошо, и отдельные токены не будут иметь назначенных векторов.Итак, чтобы использовать
 реальных  словесных векторов, вам нужно загрузить больший пакет конвейера: 
 
  - python -m spacy скачать en_core_web_sm
+ python -m spacy скачать en_core_web_lg
  
 
 Пакеты пайплайнов, которые поставляются со встроенными векторами слов, делают их доступными как
атрибут  Token.vector .
 Doc.vector  и  Span.vector  будут
по умолчанию используется среднее значение их векторов токенов. Вы также можете проверить, есть ли у токена
назначенный вектор и получить норму L2, которую можно использовать для нормализации векторов.
 
  импортное пространство

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

для токена в токенах:
    print(token.text, token.has_vector, token.vector_norm, token.is_oov)
  
 
 
  Текст  : Исходный текст токена. 
 
  имеет вектор  : Имеет ли токен векторное представление? 
 
  Норма вектора  : Норма L2 вектора токена (квадратный корень из
сумма квадратов значений) 
 
  OOV  : Out-of-vocabulary 
 
 
 Слова «собака», «кошка» и «банан» довольно распространены в английском языке, поэтому они
часть словаря пайплайна и идут с вектором.Слово «afskfsd» на
другая рука встречается гораздо реже и не входит в словарный запас, поэтому ее вектор
представление состоит из 300 измерений  0  , что означает, что это практически
несуществующий. Если ваше приложение выиграет от  большого словаря  с
больше векторов, вам следует рассмотреть возможность использования одного из более крупных пакетов пайплайна или
загрузка в полный векторный пакет, например,
 en_core_web_lg  , включая  685 тыс. уникальных
векторы  . 
 
 spaCy может сравнить два объекта и сделать прогноз  насколько они похожи
они  .Прогнозирование сходства полезно для построения рекомендательных систем.
или пометка дубликатов. Например, вы можете предложить пользовательский контент,
аналогично тому, что они сейчас просматривают, или пометить заявку в службу поддержки как
дублировать, если он очень похож на уже существующий. 
 
 Каждый  Doc ,  Span ,  Token  и
 Лексема  поставляется с  .similarity 
метод, позволяющий сравнить его с другим объектом и определить
сходство.Конечно, сходство всегда субъективно – будь то два слова, промежутки
или документы похожи, действительно зависит от того, как вы на это смотрите. spaCy’s
реализация подобия обычно предполагает довольно общее определение
сходство. 
 
 📝 Что попробовать 
 
 
 Сравните два разных жетона и попытайтесь найти два самых непохожих  
токены в текстах с наименьшим показателем сходства (по
векторы). 
 
 Сравните сходство двух объектов  лексемы , записи в
словарь.Вы можете получить лексему через атрибут  .lex  токена.
Вы должны увидеть, что результаты подобия идентичны токену
сходство. 
 
 
  импортное пространство

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


печать (doc1, "<->", doc2, doc1.similarity (doc2))

french_fries = doc1[2:4]
гамбургеры = doc1[5]
print(french_fries, "<->", burgers, french_fries.similarity(burgers))
  
 
 Чего ожидать от результатов сходства 
 
 Вычисление показателей сходства может быть полезным во многих ситуациях, но также
важно поддерживать  реалистичные ожидания  относительно того, какую информацию он может
предоставлять.Слова могут быть связаны друг с другом по-разному, поэтому одно
Оценка «сходства» всегда будет 90 451 смесью различных сигналов 90 452 и векторов.
обучение на разных данных может дать очень разные результаты, которые могут не
полезно для вашей цели. Вот несколько важных соображений, о которых следует помнить: 
 
 
 Не существует объективного определения сходства. Будь то «я люблю бургеры» и «я
как паста» похож на  зависит от вашего приложения  . Оба говорят о еде
предпочтения, что делает их очень похожими, но если вы анализируете упоминания
еды, эти предложения довольно непохожи, потому что они говорят об очень
разные продукты.
 
 Сходство  Doc  и  Span  объектов по умолчанию
к  среднему  токен-векторов. Это означает, что вектор для «быстрого
еда» — это среднее значение векторов «быстро» и «еда», которое не
обязательно представитель фразы «фаст-фуд». 
 
 Усреднение вектора означает, что вектор нескольких токенов  нечувствителен к
порядок  слов. Два документа, выражающие одно и то же значение с
разнородная формулировка вернет более низкую оценку сходства, чем два документа.
которые содержат одни и те же слова, но выражают разные значения.
 
 
 💡Совет: проверьте sense2vec 
 
 
 
  sense2vec  — это библиотека, разработанная
нас, который строится на основе 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("Цецилий est in horto")
doc2 = nlp_latin ("servus est in atrio")
документ1.сходство(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  
 
 Как оптимизировать векторное покрытие¶ 
 

 Класс Vectors  позволяет сопоставить  несколько ключей  с одним и тем же 
строка  таблицы. Если вы используете
 spacy init vectors  команда для создания словаря,
обрезка векторов будет выполнена автоматически, если вы установите  --prune 
флаг.Вы также можете сделать это вручную, выполнив следующие шаги: 
 
 
 Начните с пакета векторов из  слова , который охватывает огромный словарный запас. Для
Например, пакет  en_core_web_lg  предоставляет
300-мерные векторы GloVe для 685 тысяч терминов английского языка. 
 
 Если в вашем словаре установлены значения атрибута  Lexeme.prob ,
лексемы будут отсортированы по убыванию вероятности, чтобы определить, какие векторы
подрезать. В противном случае лексемы будут отсортированы по порядку в словаре   .
 
 Звонок  Vocab.prune_vectors  с номером
векторы, которые вы хотите сохранить. 
 
 
  nlp = spacy.load ("en_core_web_lg")
n_vectors = 105000
удаленные_слова = nlp.vocab.prune_vectors (n_vectors)

утверждать len(nlp.vocab.vectors) <= n_vectors
утверждать nlp.vocab.vectors.n_keys > n_vectors
  
 
  Vocab.prune_vectors  уменьшает текущий вектор
таблицу с заданным количеством уникальных записей и возвращает словарь, содержащий
удаленные слова, сопоставленные с  (строка, оценка)  кортежей, где  строка  — это
запись, с которой было сопоставлено удаленное слово, и  баллов  баллов сходства между
два слова.
 
  
 Удаленные слова 
   {
    «Берег»: («берег», 0,732257),
    «Осторожно»: («Осторожно», 0,4