С чего начать
Настройка NLTK и spaCy
NLTK хорош для обучения и исследований; spaCy готов к продакшену и быстр. Модели spaCy возвращают объекты Doc с разбитым на токены текс том, POS-тегами, зависимостями и другим. Устанавливайте языковые модели командой 'python -m spacy download <model>' — en_core_web_sm это небольшая английская модель.
# install NLTK and spaCy
pip install nltk spacy
python -m spacy download en_core_web_sm
import nltk
import spacy
# download NLTK data
nltk.download('punkt')
nltk.download('stopwords')
# load a spaCy model
nlp = spacy.load("en_core_web_sm")
doc = nlp("Apple is looking at buying a U.K. startup.")
for token in doc:
print(token.text, token.pos_, token.dep_)Основы конвейера spaCy
Конвейер spaCy модульный: токенизатор всегда идёт первым, затем необязательные компоненты вроде tagger, parser, ner. Отключение неиспользуемых компонентов даёт большой прирост скорости (например, для эмбеддингов нужен только tok2vec). Используйте nlp.pipe() для батчей — гораздо быстрее, чем вызывать nlp() в цикле.
import spacy
# blank pipeline (no pretrained components)
nlp_blank = spacy.blank("en")
# full pipeline: tokenizer -> tagger -> parser -> ner -> ...
nlp = spacy.load("en_core_web_sm")
print(nlp.pipe_names) # ['tok2vec', 'tagger', 'parser', 'ner', ...]
# disable components you don't need (faster)
nlp_fast = spacy.load("en_core_web_sm", disable=["parser", "ner"])
# process many texts efficiently
docs = list(nlp.pipe(["Hello world.", "SpaCy is fast."]))
# stream from file with nlp.pipe(texts, batch_size=1000)Корпусы и данные NLTK
NLTK поставляется с обёртками для многих классических корпусов: Gutenberg (книги), Brown (категоризированный текст), Reuters (новости), WordNet (лексикон). Загрузки одноразовые и кешируются. Полезны для учебников и бенчмарков, но для продакшена предпочитайте современные наборы данных из Hugging Face 'datasets'.
import nltk
# one-time downloads (cached in ~/nltk_data)
nltk.download('gutenberg') # Project Gutenberg books
nltk.download('reuters') # Reuters news corpus
nltk.download('brown') # Brown corpus (categorized)
nltk.download('wordnet') # lexical database
nltk.download('averaged_perceptron_tagger')
from nltk.corpus import gutenberg, brown
# first sentences of Moby Dick
print(gutenberg.sents('melville-moby_dick.txt')[0][:8])
# Brown corpus categories
print(brown.categories()) # ['news', 'editorial', 'reviews', ...]
news_words = brown.words(categories='news')Первый NLP-скрипт (статистика текста)
Быстрый способ охарактеризовать текст: число токенов, число предложений, уникальные леммы и частота значимых слов (после удаления стоп-слов). Doc в spaCy итерируем и даёт предложения через doc.sents. Counter из collections — простейший инструмент подсчёта частот.
import spacy
nlp = spacy.load("en_core_web_sm")
text = "The quick brown fox jumps over the lazy dog. The dog barks."
doc = nlp(text)
# basic stats
print("Tokens:", len(doc))
print("Sentences:", len(list(doc.sents)))
print("Unique words:", len({t.lemma_.lower() for t in doc if t.is_alpha}))
# word frequency
from collections import Counter
words = [t.text.lower() for t in doc if not t.is_stop and t.is_alpha]
print(Counter(words).most_common(5))Чтение и очистка текстовых файлов
Реальный текст грязен: непостоянная кодировка, HTML, типографские кавычки, тире. Всегда читайте с явным utf-8. Нормализуйте пробелы и удаляйте HTML перед токенизацией. Приведение к нижнему регистру теряет информацию (US против us) — делайте это только для задач в стиле мешка слов, но не для NER или POS-разметки.
import re
from pathlib import Path
# read with proper encoding
raw = Path("doc.txt").read_text(encoding="utf-8")
# normalize whitespace
text = re.sub(r"\s+", " ", raw).strip()
# remove HTML tags
text = re.sub(r"<[^>]+>", " ", text)
# fix curly quotes / dashes to ASCII
text = text.replace("\u2019", "'").replace("\u201c", '"')
text = text.replace("\u2013", "-").replace("\u2014", "-")
# lowercase only if case-insensitive task
clean = text.lower()Токенизация
Токенизация слов и предложений в NLTK
Токенизатор punkt в NLTK делит предложения с помощью обученной модели, которая справляется с сокращениями вроде 'Mr.'. word_tokenize использует соглашение Treebank, которое разделяет сокращения ('don't' -> 'do' + "n't"). Выбирайте токенизатор, соответствующий обучению вашей нижележащей модели: несовпадение токенизации незаметно ухудшает качество.
from nltk.tokenize import word_tokenize, sent_tokenize
text = "Hello there! How are you? I'm fine, thanks."
# sentence split (handles abbreviations)
sents = sent_tokenize(text)
# ['Hello there!', 'How are you?', "I'm fine, thanks."]
# word split (handles contractions, punctuation)
tokens = word_tokenize(text)
# ['Hello', 'there', '!', 'How', 'are', 'you', '?',
# 'I', "'m", 'fine', ',', 'thanks', '.']
# treebank tokenizer: 'don't' -> ['do', "n't"]
from nltk.tokenize import TreebankWordTokenizer
print(TreebankWordTokenizer().tokenize("don't stop"))Токенизация в spaCy
Токенизатор spaCy неразрушающий: он никогда не теряет соответствие между токенами и исходным текстом (tok.idx даёт смещение в символах). Это важно для NER и подсветки. Пользовательские правила infix/exception позволяют настроить разбиение, не переписывая весь конвейер.
import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("Let's go to N.Y.C. on 03/14/2023 for $5.50!")
# tokens keep their position in the original text
for tok in doc:
print(f"{tok.text!r:12} start={tok.idx} end={tok.idx + len(tok.text)}")
# spans: contiguous slices of the Doc
span = doc[2:5] # 'go to N.Y.C.'
print(span.text)
# spaCy never loses alignment to the original string
print(doc.text == "".join(t.text_with_ws for t in doc)) # TrueRegex-токенизатор
Regex-токенизаторы быстры и детерминированы — хороши, когда вы контролируете формат текста. \w+ отбрасывает пунктуацию и числа как слова; сочетайте его с задачей осторожно. WhitespaceTokenizer — самое дешёвое разбиение, но пунктуация слипается со словами, что обычно требует второго прохода очистки.
from nltk.tokenize import RegexpTokenizer
# words only (drop punctuation)
tok = RegexpTokenizer(r"\w+")
print(tok.tokenize("Hello, world! 123")) # ['Hello', 'world', '123']
# keep contractions: \w+|'\w+
tok2 = RegexpTokenizer(r"\w+|'\w+")
print(tok2.tokenize("don't stop")) # ['do', "n't", 'stop']
# whitespace tokenizer (keeps punctuation attached)
from nltk.tokenize import WhitespaceTokenizer
print(WhitespaceTokenizer().tokenize("Hi! Bye.")) # ['Hi!', 'Bye.']Субтокенизация (BPE / WordPiece)
Субтокенизаторы (BPE, WordPiece, Unigram, SentencePiece) разбивают редкие слова на частые фрагменты, балансируя размер словаря и покрытие. Они стандартны для современных трансформеров: BERT использует WordPiece, GPT-2 — BPE, T5 — SentencePiece. Обучайте на своём корпусе, чтобы соответствовать целевой предметной области.
from tokenizers import Tokenizer
from tokenizers.models import BPE
from tokenizers.trainers import BpeTrainer
from tokenizers.pre_tokenizers import Whitespace
# train a Byte-Pair-Encoding tokenizer
tokenizer = Tokenizer(BPE(unk_token="[UNK]"))
tokenizer.pre_tokenizer = Whitespace()
trainer = BpeTrainer(
special_tokens=["[UNK]", "[PAD]", "[CLS]", "[SEP]"],
vocab_size=8000,
)
tokenizer.train(files=["corpus.txt"], trainer=trainer)
enc = tokenizer.encode("Tokenization is fun.")
print(enc.tokens) # ['Tok', 'eni', 'zer', ...]
print(enc.ids) # [34, 912, ...]Свои правила токенизатора spaCy
Используйте add_special_case для предметных терминов (URL, хештегов, названий лекарств), с которыми токенизатор по умолчанию не справляется. Изменение шаблонов infix/prefix/suffix меняет глобальное поведение разбиения — тестируйте на выборке. Предпочитайте специальные случаи полной переписи: они чисто сочетаются с остальным конвейером.
import spacy
from spacy.tokenizer import Tokenizer
from spacy.util import compile_infix_regex, compile_prefix_regex
nlp = spacy.load("en_core_web_sm")
# add a special-case rule
specials = {"gimme": [{ORTH: "gim"}, {ORTH: "me"}]}
for text, pattern in specials.items():
nlp.tokenizer.add_special_case(text, pattern)
print([t.text for t in nlp("gimme that")]) # ['gim', 'me', 'that']
# customize infixes (e.g. split on hyphens)
infixes = compile_infix_regex([r"-"])
nlp.tokenizer.infix_finditer = infixes.finditer
print([t.text for t in nlp("state-of-the-art")])Токенизаторы трансформеров (Hugging Face)
Всегда используйте модель с её точным токенизатором: несовпадающие словари незаметно ломают всё. AutoTokenizer.from_pretrained автоматически выбирает нужный класс (BertTokenizer, GPT2Tokenizer и т. д.). bert-base-uncased приводит к нижнему регистру и добавляет [CLS]/[SEP]; варианты cased сохраняют регистр. Задавайте truncation/max_length, чтобы избежать ошибок на длинных входах.
from transformers import AutoTokenizer
# load the tokenizer matching a pretrained model
tok = AutoTokenizer.from_pretrained("bert-base-uncased")
enc = tok("Tokenization with BERT.", return_tensors="pt")
print(enc.keys()) # dict_keys(['input_ids', 'token_type_ids', 'attention_mask'])
print(enc["input_ids"]) # tensor([[101, 19204, 3989, 102]])
print(tok.convert_ids_to_tokens(enc["input_ids"][0]))
# ['[CLS]', 'tokenization', 'with', 'bert', '.', '[SEP]']
# handle long inputs with sliding window
print(tok("Very long text", truncation=True, max_length=512))POS-разметка
POS-разметка в NLTK
Стандартный перцептронный теггер использует тегсет Penn Treebank (NN — существительное, VB — глагол, JJ — прилагательное, PRP — местоимение...). Он контекстно-зависим: 'permit' как глагол (VB) или существительное (NN) различается по окружающим словам. POS-теги — дешёвый признак, улучшающий NER, чанкинг и извлечение по правилам.
import nltk
from nltk.tokenize import word_tokenize
nltk.download('averaged_perceptron_tagger_eng')
tokens = word_tokenize("They refuse to permit us to obtain the permit.")
tags = nltk.pos_tag(tokens)
# [('They', 'PRP'), ('refuse', 'VBP'), ('to', 'TO'),
# ('permit', 'VB'), ..., ('permit', 'NN'), ('.', '.')]
# note: the two 'permit' tokens get different tags (VB verb vs NN noun)
for word, tag in tags:
print(f"{word:10} {tag}")POS и морфология в spaCy
spaCy даёт и грубый Universal POS (pos_, независимый от языка), и детальные теги Treebank (tag_). Объект morph несёт признаки вроде времени, числа, лица. Universal-теги лучше для кросс-языковой работы; теги Treebank несут больше деталей для п равил, специфичных для английского.
import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("The children were playing happily.")
for tok in doc:
print(f"{tok.text:12} POS={tok.pos_:6} TAG={tok.tag_:5} "
f"lemma={tok.lemma_:10} morph={tok.morph}")
# tok.pos_ -> coarse Universal POS (NOUN, VERB, ADJ, ...)
# tok.tag_ -> fine-grained Treebank tag (NN, VBD, JJ, ...)
# tok.morph -> morphological features (Tense=Past, Number=Plur, ...)Универсальные POS-теги
Универсальные POS-теги (из Universal Dependencies) используют одинаковые 17 меток во всех языках — бесценно для многоязычных конвейеров. Различие PROPN (имена собственные) и NOUN важно для NER. Подсчёт доли частей речи (лексическая плотность = NOUN+VERB+ADJ / всего) — простой признак стиля текста.
# Universal Dependencies tagset (17 tags, same across languages)
# ADJ - adjective | ADP - adposition (prep/post)
# ADV - adverb | AUX - auxiliary (is, has)
# CCONJ - coordinating conj | DET - determiner (the, a)
# INTJ - interjection | NOUN - noun
# NUM - numeral | PART - particle ('s, not)
# PRON - pronoun | PROPN - proper noun
# PUNCT - punctuation | SCONJ - subordinating conj
# SYM - symbol | VERB - verb
# X - other
import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("She quickly ran to the store.")
nouns = [t.text for t in doc if t.pos_ in ("NOUN", "PROPN")]
verbs = [t.text for t in doc if t.pos_ == "VERB"]Чтение размеченных корпусов
Размеченные корпусы — золото для обучения и оценки теггеров, а также для лингвистического анализа. Brown использует богатый тегсет (с суффиксами вроде -TL для заголовков, -NC для цитат). Сравнение распределений тегов по категориям Brown (новости против художественной литературы) выявляет стилистические различия в использовании частей речи.
import nltk
from nltk.corpus import brown, treebank
# Brown: each word pre-tagged
sent = brown.tagged_sents(categories='news')[0]
print(sent) # [('The', 'AT'), ('Fulton', 'NP-TL'), ...]
# Penn Treebank ( Wall Street Journal)
for s in treebank.tagged_sents()[:1]:
print(s)
# count tag distribution
from collections import Counter
tags = [tag for w, tag in brown.tagged_words(categories='news')]
print(Counter(tags).most_common(5))Разметка по правилам и словарю
Для небольших или предметно-специфичных данных простые теггеры с цепочками откатов работают на удивление хорошо: сначала пробуйте самый специфичный теггер, для неизвестных слов откатывайтесь к более общему. UnigramTagger выучивает самый частый тег для каждого слова; DefaultTagger ('NN') обрабатывает невиданные слова. RegexTagger ловит числа, даты и шаблоны заглавных букв.
from nltk.tag import UnigramTagger, DefaultTagger
from nltk.corpus import brown
# fallback: tag everything as NN
default = DefaultTagger('NN')
# unigram: most-likely tag per word (from training data)
train = brown.tagged_sents(categories='news')[:3000]
uni = UnigramTagger(train, backoff=default)
# backoff chain: unigram -> default
test = brown.tagged_sents(categories='news')[3000:3100]
print(f"Accuracy: {uni.evaluate(test):.3f}")
# regex tagger for patterns
from nltk.tag import RegexpTagger
regex = RegexpTagger([(r'^-?[0-9]+(\.[0-9]+)?$', 'CD')], backoff=default)Распознавание именованных сущностей
NER в spaCy
Предобученный NER в spaCy распознаёт ORG, PERSON, GPE (геополитические объекты), DATE, MONEY и др. doc.ents — это спаны, выровненные по токенизатору. displacy.render/serve даёт наглядную HTML-визуализацию. Точность на обычных новостных текстах хорошая; для узких доменов (медицина, юриспруденция) потребуется дообучение.
import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("Apple is buying a U.K. startup for $1 billion in New York.")
for ent in doc.ents:
print(f"{ent.text:20} {ent.label_:10} {spacy.explain(ent.label_)}")
# Apple ORG Companies, agencies, institutions
# U.K. GPE Countries, cities, states
# $1 billion MONEY Monetary values
# New York GPE Countries, cities, states
# visualize
from spacy import displacy
displacy.serve(doc, style="ent") # opens a browserЧанкинг сущностей в NLTK
ne_chunk в NLTK сочетает POS-разметку с чанкером на основе грамматики. Результат — дерево, где именованные сущности являются поддеревьями с метками PERSON, ORGANIZATION, GPE и т. д. Это медленнее и менее точно, чем spaCy, но полезно для изучения концепции чанкинга и правил-расширений.
import nltk
from nltk.tokenize import word_tokenize, sent_tokenize
text = "Barack Obama was born in Hawaii and led the USA."
sents = sent_tokenize(text)
for s in sents:
tokens = word_tokenize(s)
tags = nltk.pos_tag(tokens)
# ne_chunk returns a nested tree of named entities
tree = nltk.ne_chunk(tags)
print(tree)
# (S
# (PERSON Barack/NNP Obama/NNP)
# was/VBD born/VBN in/IN
# (GPE Hawaii/NNP) ...)
# extract just the named entities
for node in tree:
if hasattr(node, 'label'):
name = " ".join(w for w, t in node)
print(node.label(), name)Типы сущностей и метки
Английский NER в spaCy использует набор меток OntoNotes — широкое покрытие персон, организаций, локаций, дат, денег, количеств. spacy.explain(label) даёт человекочитаемое описание. Для более тонких типов (например, отличить CEO от COMPANY) обучайте собственную модель или используйте внешнюю базу знаний.
import spacy
nlp = spacy.load("en_core_web_sm")
# list all labels the model knows
for label in nlp.get_pipe("ner").labels:
print(f"{label:12} {spacy.explain(label)}")
# PERSON People, including fictional
# NORP Nationalities or religious/political groups
# FAC Buildings, airports, highways
# ORG Companies, agencies, institutions
# GPE Countries, cities, states
# LOC Non-GPE locations: mountain ranges, bodies of water
# PRODUCT Vehicles, food, clothing (not services)
# EVENT Battles, wars, sports events
# DATE Absolute or relative dates
# TIME Times smaller than a day
# MONEY Monetary values
# QUANTITY Measurements (weight, distance)
# ORDINAL First, second, ...
# CARDINAL Numerals that are not dates or amountsОбучение собственной NER-модели
Дообучайте NER, когда предобученные метки не подходят домену. Подавайте обучающие данные как (text, {entities: [(start, end, label)]}) с символьными смещениями: spaCy нужны точные спаны. Начинайте с en_core_web_sm, а не с пустой модели, чтобы использовать имеющиеся признаки. 30–50 примеров на тип сущности — разумный минимум; используйте use_eval для ранней остановки.
import spacy
from spacy.training import Example
# start from a blank model (or fine-tune a pretrained one)
nlp = spacy.blank("en")
ner = nlp.add_pipe("ner")
ner.add_label("DRUG")
# training data: text + character offsets of entities
TRAIN = [
("Take aspirin daily.", {"entities": [(5, 11, "DRUG")]}),
("Ibuprofen reduces fever.", {"entities": [(0, 9, "DRUG")]}),
]
optimizer = nlp.initialize()
for epoch in range(30):
for text, ann in TRAIN:
doc = nlp.make_doc(text)
nlp.update([Example.from_dict(doc, ann)], sgd=optimizer)
# save and use
nlp.to_disk("custom_ner")
doc = nlp("Give metformin 500mg.")
print([(e.text, e.label_) for e in doc.ents]) # [('metformin', 'DRUG')]Связывание сущностей и викификация
NER находит упоминания; связывание сущностей разрешает их неоднозначность до записи в базе знаний (какой именно 'Apple'? компания или фрукт). Полное связывание требует базы знаний, генератора кандидатов и дезамбигуатора. Встроенному EntityLinker в spaCy нужна построенная вами база знаний; для продакшена рассмотрите REL, mGENRE или коммерческие API (Google KG, Bing Entity Search).
# Entity linking maps a mention to a unique ID in a knowledge base
# (e.g. "Apple" -> Apple Inc. the company, not the fruit)
import spacy
nlp = spacy.load("en_core_web_sm")
# spaCy's EntityLinker requires a knowledge base (KB).
# Building one from Wikipedia/Wikidata is involved; in practice use:
# Option 1: spaCy + Wikipedia-based KB (spacy-entity-linker)
# pip install spacy-entity-linker
# from spacy_entity_linker import EntityLinker
# linker = EntityLinker()
# nlp.add_pipe("entityLinker", last=True)
# Option 2: a dedicated library
# import entitylinking # or use a Wikidata API directly
# Example query via Wikidata SPARQL
import requests
url = "https://www.wikidata.org/w/api.php"
params = {"action": "wbsearchentities", "search": "Apple",
"language": "en", "format": "json"}
print(requests.get(url, params=params).json())Стемминг и лемматизация
Стеммер Портера
PorterStemmer применяет фиксированную последовательность правил отсечения суффиксов. Он быстр и детерминирован, но выдаёт не-слова ('easili', 'studi') и игнорирует контекст: 'ran' остаётся 'ran', потому что суффикса для отсечения нет. Подходит для поисковых движков и тематических моделей, где согласованность стемов важнее правильности.
from nltk.stem import PorterStemmer
stemmer = PorterStemmer()
for w in ["running", "runs", "ran", "easily", "fairness", "studies"]:
print(f"{w:10} -> {stemmer.stem(w)}")
# running -> run
# runs -> run
# ran -> ran (Porter doesn't handle irregulars)
# easily -> easili (sometimes ugly)
# fairness -> fair
# studies -> studi
# fast, rule-based, deterministic
print([stemmer.stem(t) for t in "the cats are running".split()])Стеммер Snowball
SnowballStemmer — модернизированный Porter (вариант 'English') — добавляет ещё 15+ языков. Он чуть точнее и поддерживает неанглийский текст из коробки. Если нужно многоязычное стеммирование б ез словарей, Snowball — практичный выбор по умолчанию; для более высокого качества переходите к лемматизатору.
from nltk.stem import SnowballStemmer
# Snowball = improved Porter, supports many languages
print(SnowballStemmer.languages)
# ['arabic', 'danish', 'dutch', 'english', 'finnish', 'french',
# 'german', 'hungarian', 'italian', 'norwegian', 'porter',
# 'portuguese', 'romanian', 'russian', 'spanish', 'swedish']
en = SnowballStemmer("english")
print(en.stem("running"), en.stem("fairly"), en.stem("studies"))
# run fair studi
# compare two languages
fr = SnowballStemmer("french")
print(fr.stem("mangerons")) # mangЛемматизатор WordNet
Лемматизация возвращает настоящие словарные слова ('better' -> 'good', 'mice' -> 'mouse'), обращаясь к WordNet. Ей нужна часть речи для снятия неоднозначности ('running' — существительное или глагол). Накладные расходы POS-разметки оправданы, когда нижележащие признаки (BoW, TF-IDF) выигрывают от канонических форм. Медленнее стемминга из-за обращений к словарю.
import nltk
from nltk.stem import WordNetLemmatizer
nltk.download('wordnet')
lem = WordNetLemmatizer()
# without POS, defaults to NOUN
print(lem.lemmatize("running")) # running (treated as noun)
print(lem.lemmatize("running", pos='v')) # run (verb)
print(lem.lemmatize("better", pos='a')) # good (adjective)
print(lem.lemmatize("mice")) # mouse (irregular plural)
# pipeline: tokenize -> POS tag -> lemmatize with correct POS
from nltk.tokenize import word_tokenize
from nltk import pos_tag
words = word_tokenize("The cats were running quickly.")
treebank_to_wordnet = {'N': 'n', 'V': 'v', 'J': 'a', 'R': 'r'}
for w, t in pos_tag(words):
wn_pos = treebank_to_wordnet.get(t[0], 'n')
print(w, '->', lem.lemmatize(w, pos=wn_pos))Лемматизация в spaCy
spaCy лемматизирует внутри конвейера — с учётом части речи и без лишнего кода обрабатывает неправильные формы ('ate'->'eat', 'were'->'be'). Использование lemma_ вместо text сводит 'cat'/'cats' в один признак, уменьшая словарь. Для многоязычных моделей качество лемматизации различается; смотрите отчёт о точности модели.
import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("The cats were running faster. I ate two apples.")
for tok in doc:
if tok.text.lower() != tok.lemma_:
print(f"{tok.text:10} -> {tok.lemma_}")
# cats -> cat
# were -> be
# running -> run
# faster -> fast
# ate -> eat
# apples -> apple
# context-aware, handles irregulars automatically
# use lemma_ instead of text for bag-of-words features
docs_tokens = [[t.lemma_.lower() for t in nlp(d) if not t.is_stop]
for d in ["Cats run.", "The cat ran."]]Стемминг против лемматизации
Стемминг быстрее, но выдаёт не-слова и для некоторых задач склеивает слишком агрессивно. Лемматизация возвращает допустимые слова и учитывает часть речи ценой обращений к словарю. Для признаков мешка слов оба уменьшают словарь; для пользовательского вывода (например, списков ключевых слов) всегда лемматизируйте. Для поиска в огромном масштабе стемминг — прагматичный выбор.
import spacy
from nltk.stem import PorterStemmer
nlp = spacy.load("en_core_web_sm")
stem = PorterStemmer()
words = ["studies", "studying", "better", "feet", "running", "happily"]
print(f"{'word':12}{'stem':12}{'lemma':12}")
for w in words:
lemma = nlp(w)[0].lemma_
print(f"{w:12}{stem.stem(w):12}{lemma:12}")
# studies studi study
# studying studi study
# better better good <- lemma handles irregular
# feet feet foot
# running run run
# happily happili happily
# rule of thumb:
# search/indexing/topic-models -> stemming (fast)
# interpretation/visualization -> lemmatization (accurate)Стоп-слова
Стоп-слова NLTK
NLTK поставляет компактные списки стоп-слов по языкам (~180 слов для английского). Используйте set для поиска за O(1). Всегда приводите к нижнему регистру перед проверкой, так как списки в нижнем регистре. Фильтрация уменьшает словарь и убирает малозначимые слова — полезно для тематических моделей и поисковых индексов, но вредно для тональности («not good» теряет отрицание).
import nltk
from nltk.corpus import stopwords
nltk.download('stopwords')
# 18 languages available
print(stopwords.fileids())
# ['arabic', 'english', 'french', 'german', 'spanish', ...]
en = set(stopwords.words('english'))
print(len(en)) # 179
print("the" in en) # True
print("python" in en) # False
# remove from a token list
from nltk.tokenize import word_tokenize
text = "The quick brown fox is very lazy indeed"
tokens = [w for w in word_tokenize(text.lower()) if w.isalpha()]
filtered = [w for w in tokens if w not in en]
print(filtered) # ['quick', 'brown', 'fox', 'lazy']Стоп-слова spaCy
spaCy помечает is_stop у каждого токена, включая сокращения ('isn't'). Список по умолчанию больше, чем у NLTK (326 слов). Используйте is_stop вместе с is_punct и is_alpha для чистого извлечения значимых слов. Список хранится в nlp.Defaults.stop_words и может редактироваться во время работы для каждого конвейера.
import spacy
nlp = spacy.load("en_core_web_sm")
# access the stopword set
print(len(nlp.Defaults.stop_words)) # 326
print("the" in nlp.Defaults.stop_words) # True
# tokens expose is_stop directly
doc = nlp("The quick fox isn't lazy")
for tok in doc:
print(f"{tok.text:8} is_stop={tok.is_stop}")
# The is_stop=True
# quick is_stop=False
# isn't is_stop=True (contraction included)
# content words only
content = [t.text for t in doc if not t.is_stop and not t.is_punct]Безопасное удаление стоп-слов
Слепое удаление стоп-слов может уничтожить информацию: отрицания («not good» -> «good»), многословные сущности («New York» в порядке, но «out of» может быть важным) и структуру вопроса («What is X?» -> «X?»). Для тональности всегда сохраняйте отрицания. Для NER никогда не удаляйте стоп-слова перед извлечением сущностей.
import spacy
nlp = spacy.load("en_core_web_sm")
def remove_stopwords(text, keep_negations=True):
doc = nlp(text)
out = []
for tok in doc:
if tok.is_stop or tok.is_punct:
# keep negations for sentiment tasks
if keep_negations and tok.lemma_ in ("not", "no", "never"):
out.append(tok.text)
continue
continue
out.append(tok.text)
return " ".join(out)
print(remove_stopwords("I do not like green eggs and ham."))
# 'not like green eggs ham .'
# bigrams preserve phrases that stopwords broke:
# 'New York' should NOT lose its inner stopwords...Свои списки стоп-слов
Общие списки не учитывают предметный шум ('reuters', 'inc', 'said' в новостях). Ищите в корпусе очень частые малозначимые слова и добавляйте их. И наоборот, удаляйте слова, важные для задачи (отрицания, модальные глаголы для определения позиции). Сохраняйте изменённый конвейер, чтобы собственный список шёл вместе с моделью.
import spacy
nlp = spacy.load("en_core_web_sm")
# add domain-specific stopwords
domain_stops = {"said", "says", "say", "according", "reuters", "inc", "ltd"}
for w in domain_stops:
nlp.Defaults.stop_words.add(w)
# also set the lexeme attribute
lex = nlp.vocab[w]
lex.is_stop = True
# remove a word that you DO want to keep
nlp.Defaults.stop_words.discard("not")
nlp.vocab["not"].is_stop = False
# persist by saving the modified model
# nlp.to_disk("my_model_with_stops")Когда оставлять стоп-слова
Глубокие модели (BERT, GPT) обучались на естественном тексте, включая стоп-слова: предварительное удаление ухудшает качество, потому что модель опирается на служебные слова для синтаксиса. Удаление стоп-слов — приём инженерии признаков для неглубоких моделей; проверьте оба варианта и оставьте тот, что выше по вашей валидационной метрике.
# Stopword removal HELPS:
# - bag-of-words / TF-IDF (smaller vocab, less noise)
# - topic modeling (LDA wants content words)
# - search indexing (precision up, index smaller)
# Stopword removal HURTS:
# - sentiment analysis ("not good" != "good")
# - NER / entity extraction (alignment breaks)
# - syntax parsing (function words are syntactic glue)
# - transformer models (they were pretrained WITH stopwords)
from transformers import AutoTokenizer
tok = AutoTokenizer.from_pretrained("bert-base-uncased")
# NEVER strip stopwords before feeding BERT — the model
# expects natural text and uses function words syntactically.
# rule: only remove stopwords for shallow features (BoW/TF-IDF),
# and only if you've checked it doesn't hurt your metric.Мешок слов и векторизация
Основы CountVectorizer
CountVectorizer превращает список строк в разреженную матрицу документов-терминов. fit_transform изучает словарь и преобразует за один шаг; transform применяет изученный словарь к новым данным (критично: никогда не делайте повторный fit на тестовых данных). Матрица разреженная, чтобы эффективно работать с большим словарём. Шаблон токенов по умолчанию \b\w\w+\b отбрасывает односимвольные токены.
from sklearn.feature_extraction.text import CountVectorizer
docs = ["The cat sat on the mat.", "The dog sat on the log."]
# default: lowercase, word tokenizer (\b\w\w+\b), unigrams
vec = CountVectorizer()
X = vec.fit_transform(docs)
print(X.shape) # (2, 6) -> 2 docs, 6 unique words
print(vec.get_feature_names_out())
# ['cat' 'dog' 'log' 'mat' 'on' 'sat' 'the']
print(X.toarray())
# [[1 0 0 1 1 1 2] 'the' appears twice in doc 0
# [0 1 1 0 1 1 2]]
# transform new text with the fitted vocabulary
new = vec.transform(["The cat and the dog."])N-граммы
N-граммы сохраняют локальный порядок слов, который теряют униграммы: «not good» против «good». Биграммы ре зко увеличивают словарь (квадратично), поэтому сочетайте их с min_df (убрать редкие) или max_features (ограничить топ-K). Триграммы редко окупаются для мешка слов; для более длинного контекста переходите к эмбеддингам.
from sklearn.feature_extraction.text import CountVectorizer
docs = ["I love this movie", "I hate this movie"]
# unigrams + bigrams
vec = CountVectorizer(ngram_range=(1, 2))
X = vec.fit_transform(docs)
print(vec.get_feature_names_out())
# ['hate', 'hate this', 'love', 'love this', 'movie',
# 'this', 'this movie']
# bigrams capture phrases like "not good", "New York"
# but explode the vocabulary -> pair with min_df / max_features
vec2 = CountVectorizer(ngram_range=(2, 2), min_df=2)
# (2,2) = bigrams only; min_df=2 keeps bigrams seen >= 2 timesHashingVectorizer
HashingVectorizer не хранит состояние: он хеширует каждый токен в индекс колонки, поэтому словарь не нужно хранить. Отлично для потоковой обработки и ограниченной памяти. Компромисс: нельзя узнать, какое слово соответствует колонке, а коллизии сливают признаки. Установите alternate_sign=False, чтобы избежать смены знаков, взаимно гасящих счётчики в линейных моделях.
from sklearn.feature_extraction.text import HashingVectorizer
# stateless: no vocabulary kept, uses feature hashing
vec = HashingVectorizer(n_features=2**18, alternate_sign=False)
X = vec.transform(["doc one", "doc two"])
print(X.shape) # (2, 262144)
# pros: no memory for vocabulary, streamable, fit_transform = transform
# cons: hashes are not interpretable, possible collisions,
# no inverse_transform (can't map feature -> word)
# use for: very large / streaming corpora where you don't need
# to know which word a column corresponds toУправление словарём
min_df и max_df — самые полезные настройки: они отбрасывают редкие опечатки и общекорпусные стоп-слова соответственно, уменьшая матрицу и шум. max_features ограничивает словарь ради памяти. Пользовательский token_pattern фильтрует по длине или классу символов. Фиксированный словарь удобен, когда нужно сохранять стабильность колонок между запусками.
from sklearn.feature_extraction.text import CountVectorizer
docs = ["a a a b b c rareword commontoken"] * 5
vec = CountVectorizer(
min_df=2, # ignore terms in <2 docs
max_df=0.9, # ignore terms in >90% of docs (corpus-specific stops)
max_features=1000, # keep only top-1000 by frequency
stop_words='english',
token_pattern=r"\b[a-z]{2,}\b", # only 2+ letter words
)
X = vec.fit_transform(docs)
print(vec.get_feature_names_out())
# fix a custom vocabulary (only these words are counted)
vec_fixed = CountVectorizer(vocabulary=["cat", "dog", "fish"])
print(vec_fixed.get_feature_names_out())Операции с разреженными матрицами
Матрицы документов-терминов разреженные (в основном нули) — храните их разреженными, чтобы не взорвать память (плотная матрица 100k×50k float64 потребовала бы 40 ГБ). Используйте .sum(axis=0), .multiply(), срезы по разреженному объекту. Вызывайте .toarray() только на небольших срезах. Формат CSR оптимизирован для срезов по строкам; для срезов по колонкам конвертируйте в CSC.
from sklearn.feature_extraction.text import CountVectorizer
import numpy as np
from scipy.sparse import csr_matrix
docs = ["the cat sat", "the dog ran", "the cat ran"]
vec = CountVectorizer()
X = vec.fit_transform(docs) # CSR sparse matrix
print(type(X)) # <class 'scipy.sparse.csr_matrix'>
print(X.shape, X.nnz) # (3, 5) 9 non-zero entries
# NEVER call .toarray() on huge matrices — they explode in memory.
# operate on sparse directly:
col_sums = np.asarray(X.sum(axis=0)).ravel() # document frequency
print(dict(zip(vec.get_feature_names_out(), col_sums)))
# find docs containing a word
word_idx = vec.vocabulary_["cat"]
rows_with_cat = X[:, word_idx].nonzero()[0]
print("docs with 'cat':", rows_with_cat) # [0, 2]TF-IDF
Основы TfidfVectorizer
TF-IDF снижает вес слов, встречающихся во многих документах (низкая различительная сила), и повышает вес редких информативных. TfidfVectorizer объединяет CountVectorizer + TfidfTransformer и L2-нормирует строки, чтобы длина документа не доминировала. Это признак по умолчанию для классификации текстов линейными моделями.
from sklearn.feature_extraction.text import TfidfVectorizer
docs = ["the cat sat on the mat",
"the dog sat on the log",
"cats and dogs are pets"]
vec = TfidfVectorizer() # default: L2-normalized rows
X = vec.fit_transform(docs)
print(vec.get_feature_names_out())
# tf-idf = term_freq * log(N / df) * (variations exist)
# down-weights words common across all docs ('the', 'sat')
print(X.toarray().round(3))
# each row is L2-normalized to length 1
import numpy as np
print(np.linalg.norm(X.toarray(), axis=1)) # [1. 1. 1.]TfidfTransformer и формула
smooth_idf добавляет +1, чтобы избежать деления на ноль для невиданных термов. sublinear_tf заменяет сырые счётчики на 1+log(count), ограничивая влияние очень частых слов внутри документа — полезно для длинных документов, где терм может повторяться десятки раз. norm='l2' стандартен; используйте None, если нужны сырые величины.
from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer
from sklearn.pipeline import Pipeline
# equivalent to TfidfVectorizer but in two steps
pipe = Pipeline([
("counts", CountVectorizer()),
("tfidf", TfidfTransformer(
norm='l2',
use_idf=True,
smooth_idf=True, # idf = ln((1+N)/(1+df)) + 1 (avoids div-by-zero)
sublinear_tf=False, # if True: tf = 1 + log(count)
)),
])
# sublinear_tf compresses high counts:
# count 5 -> tf 5 (linear) vs tf 1+log(5)≈2.6 (sublinear)
# useful when a word repeating 100x isn't 100x more important
pipe2 = Pipeline([
("counts", CountVectorizer()),
("tfidf", TfidfTransformer(sublinear_tf=True)),
])Интерпретация весов TF-IDF
Топ признаков TF-IDF по документу — быстрая сводка его характерного содержания. Слова, встречающиеся в каждом документе, получают idf≈1 (низкий вес); слова из одного документа — максимальный idf. Смотрите vec.idf_, чтобы увидеть выученные глобальные веса. Это отличная проверка перед обучением классификатора.
from sklearn.feature_extraction.text import TfidfVectorizer
import numpy as np
docs = ["machine learning models", "deep learning networks",
"natural language processing"]
vec = TfidfVectorizer()
X = vec.fit_transform(docs)
names = vec.get_feature_names_out()
# top features per document
for i, doc in enumerate(docs):
row = X[i].toarray().ravel()
top = np.argsort(row)[::-1][:3]
print(f"doc {i}: {[(names[j], round(row[j], 3)) for j in top]}")
# doc 0: [('machine', 0.58), ('models', 0.58), ('learning', 0.41)]
# doc 1: [('deep', 0.5), ('networks', 0.5), ...]
# doc 2: [('natural', 0.41), ('processing', 0.41), ('language', 0.41)]
# inspect the learned idf weights
idf = dict(zip(names, vec.idf_))
print(sorted(idf.items(), key=lambda x: x[1])[:3]) # lowest idf = most commonTF-IDF с n-граммами и стоп-словами
Сочетание TF-IDF с биграммами сохраняет отрицание («not good»), которое теряют униграммы. stop_words='english' вместе с min_df уменьшает словарь. Комбинация TfidfVectorizer + LinearSVC/LogisticRegression — на удивление сильный бейзлайн: обойти её с помощью BERT стоит только при достаточном объёме размеченных данных.
from sklearn.feature_extraction.text import TfidfVectorizer
docs = ["not good at all", "very good indeed", "not bad actually"]
vec = TfidfVectorizer(
stop_words='english',
ngram_range=(1, 2), # unigrams + bigrams
min_df=1,
sublinear_tf=True,
max_features=5000,
)
X = vec.fit_transform(docs)
print(vec.get_feature_names_out())
# bigrams like 'not good', 'not bad' preserve negation
# this combination is a strong baseline for text classification
# with LogisticRegression or LinearSVCTF-IDF для сходства и поиска
Косинусное сходство по векторам TF-IDF — классический бейзлайн поиска по ключевым словам: запрос и документы становятся векторами и ранжируются по углу косинуса. Он работает без обучающих данных, но совпадает только по общему словарю: семантически близкий, но лексически другой текст (например, 'ML' и 'machine learning') не совпадёт. Для семантического поиска используйте эмбеддинги (sentence-transformers).
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
corpus = [
"Machine learning is fun",
"Python is great for ML",
"I love cooking pasta",
]
query = ["learning machine"]
vec = TfidfVectorizer()
X = vec.fit_transform(corpus)
q = vec.transform(query)
# cosine similarity between query and each doc
sims = cosine_similarity(q, X).ravel()
for doc, score in sorted(zip(corpus, sims), key=lambda x: -x[1]):
print(f"{score:.3f} {doc}")
# 0.580 Machine learning is fun
# 0.000 I love cooking pasta
# this is essentially a tiny search engineЭмбеддинги слов (Word2Vec / GloVe / FastText)
Word2Vec в gensim
Word2Vec учит плотные векторы, предсказывая контекст (skip-gram) или слово по контексту (CBOW). skip-gram (sg=1) лучше работает на малых данных и редких словах; CBOW быстрее. min_count фильтрует редкие слова. Реальным моделям нужны миллионы токенов — обучайте на Википедии или используйте предобученные векторы для большинства задач.
from gensim.models import Word2Vec
from gensim.utils import simple_preprocess
sentences = [
"the cat sat on the mat".split(),
"the dog sat on the log".split(),
"cats and dogs are pets".split(),
]
# simple_preprocess lowercases and tokenizes
sents = [simple_preprocess(" ".join(s)) for s in sentences]
model = Word2Vec(
sentences=sents,
vector_size=100, # embedding dimension
window=5, # context window size
min_count=1, # ignore words with freq < min_count
workers=4,
sg=1, # 1 = skip-gram, 0 = CBOW
epochs=10,
)
print(model.wv["cat"].shape) # (100,)
print(model.wv.most_similar("cat", topn=3))Обучение собственных эмбеддингов
Используйте генератор (SentenceIterator), чтобы корпус читался с диска потоком: gensim создан для потоковой обработки и никогда не держит всё в RAM. min_count=5 убирает опечатки и редкие слова. negative=10 — стандарт для skip-gram. Сохраняйте модель и продолжайте обучение при поступлении новых данных. Перед внедрением оценивайте на аналогиях и задачах сходства.
from gensim.models import Word2Vec
from gensim.utils import simple_preprocess
from pathlib import Path
# read a large corpus line by line (don't load all into memory)
class SentenceIterator:
def __init__(self, path):
self.path = Path(path)
def __iter__(self):
for line in self.path.open(encoding="utf-8"):
yield simple_preprocess(line)
sentences = SentenceIterator("corpus.txt")
model = Word2Vec(
sentences,
vector_size=200,
window=8,
min_count=5, # drop very rare words
workers=8,
epochs=5,
negative=10, # negative samples per positive (skip-gram)
)
model.save("w2v.model")
# resume training later
# model = Word2Vec.load("w2v.model")
# model.train(more_sentences, total_examples=len(more), epochs=5)Сходство и аналогии
Word2vec знаменит тем, что улавливает аналогии (king - man + woman ≈ queen), потому что похожие контексты дают похожие векторы. similarity возвращает косинус в [-1, 1]. doesnt_match — забавный детектор выбросов. Предобученные векторы Google News покрывают 3 млн слов, но весят 3 ГБ; GloVe или fastText часто практичнее.
from gensim.models import KeyedVectors
# load pretrained Google News vectors (3GB, 3M words)
# Download: https://code.google.com/archive/p/word2vec/
model = KeyedVectors.load_word2vec_format("GoogleNews-vectors-negative300.bin",
binary=True)
# similarity
print(model.similarity("cat", "dog")) # ~0.86
print(model.similarity("cat", "car")) # ~0.28
# analogy: king - man + woman = queen
print(model.most_similar(positive=["king", "woman"],
negative=["man"], topn=1))
# [('queen', 0.71)]
# odd one out
print(model.doesnt_match("cat dog car horse".split())) # 'car'
# which word doesn't fit
print(model.most_similar("python", topn=5))FastText
FastText расширяет Word2Vec, обучая векторы для символьных n-грамм (субслов), поэтому умеет представлять невиданные слова ('catting' из 'cat'+'ing'). Это сильно помогает для морфологически богатых языков и опечаток. Немного медленнее Word2Vec из-за поиска субслов, но обработка OOV окупается для большинства реальных текстов.
from gensim.models import FastText
sentences = [
"the cat sat on the mat".split(),
"dogs and cats are friends".split(),
]
# FastText learns subword (character n-gram) embeddings
model = FastText(
sentences,
vector_size=100,
window=5,
min_count=1,
min_n=3, # min char n-gram
max_n=6, # max char n-gram
epochs=10,
)
# KEY advantage: handles out-of-vocabulary words
print("catting" in model.wv) # False (not seen in training)
print(model.wv["catting"].shape) # (100,) -> still gets a vector!
# vector is averaged from subword n-grams of 'catting'
print(model.wv.most_similar("cat", topn=3))Загрузка векторов GloVe
GloVe (Global Vectors) обучается на счётчиках совместной встречаемости, а не на предсказаниях, давая векторы, сопоставимые с Word2Vec. Stanford поставляет версии размерности 50/100/200/300, обученные на 6 млрд токенов. Конвертируйте в формат gensim, чтобы переиспользовать API Word2Vec. Для 300-мерных векторов ожидайте ~1,5 ГБ в памяти.
# GloVe: pretrained on Wikipedia+Gigaword
# Download: https://nlp.stanford.edu/projects/glove/
# Files: glove.6B.50d.txt, glove.6B.100d.txt, glove.6B.200d.txt, glove.6B.300d.txt
from gensim.scripts.glove2word2vec import glove2word2vec
from gensim.models import KeyedVectors
# convert GloVe format to word2vec format (one-time)
glove2word2vec("glove.6B.100d.txt", "glove.6B.100d.w2v.txt")
# load
glove = KeyedVectors.load_word2vec_format("glove.6B.100d.w2v.txt")
print(glove["king"].shape) # (100,)
print(glove.most_similar("king", topn=3))
# fast alternative: load directly into a dict
import numpy as np
def load_glove(path, dim=100):
embeddings = {}
with open(path, encoding="utf-8") as f:
for line in f:
parts = line.split()
embeddings[parts[0]] = np.asarray(parts[1:], dtype="float32")
return embeddingsВизуализация эмбеддингов через t-SNE
t-SNE проецирует многомерные векторы в 2D для визуализации: близкие точки на графике похожи в пространстве эмбеддингов. Используйте perplexity от 5 до 50 в зависимости от числа точек. Учтите: t-SNE искажает глобальные расстояния, поэтому применяйте его для исследования, а не измерения. UMAP часто сохраняет структуру лучше t-SNE.
import numpy as np
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE
from gensim.models import KeyedVectors
model = KeyedVectors.load_word2vec_format("glove.6B.100d.w2v.txt")
# pick a small set of related words
words = ["king", "queen", "man", "woman", "paris", "france",
"london", "england", "dog", "cat", "horse", "cow"]
vectors = np.array([model[w] for w in words])
# reduce 100d -> 2d with t-SNE
tsne = TSNE(n_components=2, random_state=42, perplexity=5)
coords = tsne.fit_transform(vectors)
plt.figure(figsize=(8, 6))
for w, (x, y) in zip(words, coords):
plt.scatter(x, y)
plt.annotate(w, (x, y), xytext=(5, 5), textcoords="offset points")
plt.savefig("embeddings_tsne.png", dpi=120)
plt.show()Контекстные эмбеддинги (BERT)
Основы Hugging Face Transformers
AutoTokenizer/AutoModel автоматически выбирают нужный класс по имени модели на Hugging Face Hub — не нужно знать, BERT это, RoBERTa или DistilBERT. last_hidden_state содержит по одному 768-мерному вектору на токен; pooler_output — представление [CLS]. Для эмбеддингов предложений одного [CLS] часто мало — используйте sentence-transformer.
from transformers import AutoTokenizer, AutoModel
import torch
# load any pretrained model by name from the Hub
model_name = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModel.from_pretrained(model_name)
inputs = tokenizer("Hello, BERT!", return_tensors="pt")
print(inputs.keys()) # input_ids, token_type_ids, attention_mask
with torch.no_grad():
outputs = model(**inputs)
# last hidden state: (batch, seq_len, hidden_size)
print(outputs.last_hidden_state.shape) # torch.Size([1, 6, 768])
# pooled output: [CLS] token passed through a linear+tanh
print(outputs.pooler_output.shape) # torch.Size([1, 768])Токенные эмбеддинги BERT
Определяющая особенность BERT: вектор для 'bank' различается в 'river bank' и 'bank account', потому что внимание учитывает контекст. Это решает проблему многозначности — главную слабость Word2Vec/GloVe. Вектор каждого токена — контекстуализированное 768-мерное представление, построенное по всей последовательности.
from transformers import AutoTokenizer, AutoModel
import torch
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
model = AutoModel.from_pretrained("bert-base-uncased")
# contextual: 'bank' embeds differently in river vs money context
texts = ["I sat by the river bank.", "I deposited cash at the bank."]
for t in texts:
inputs = tokenizer(t, return_tensors="pt")
with torch.no_grad():
out = model(**inputs)
# find the index of 'bank'
idx = (inputs["input_ids"][0] == tokenizer.convert_tokens_to_ids("bank")).nonzero()[0]
vec = out.last_hidden_state[0, idx[0]]
print(f"{t[:25]:25} bank-vec[:3] = {vec[:3].tolist()}")
# the two 'bank' vectors DIFFER -> this is the whole point of BERT
# (static embeddings like Word2Vec would give the same vector both times)Sentence Transformers
[CLS] обычного BERT — плохой эмбеддинг предложения (оценки сходства ненадёжны). sentence-transformers дообучает модели контрастивными потерями, чтобы косинусное сходство отражало семантическую близость. all-MiniLM-L6-v2 — выбор по умолчанию: 384 измерения, быстро и конкурентно с гораздо большими моделями. Идеально для семантического поиска, кластеризации и дедупликации.
# pip install sentence-transformers
from sentence_transformers import SentenceTransformer, util
# models tuned to produce good sentence-level embeddings
model = SentenceTransformer("all-MiniLM-L6-v2") # 384d, fast & strong
sentences = [
"The cat sits on the mat.",
"A feline is resting on a rug.",
"Machine learning is fascinating.",
]
emb = model.encode(sentences, convert_to_tensor=True, normalize_embeddings=True)
# semantic similarity via cosine
print(util.cos_sim(emb, emb).round(3))
# [[1. 0.678 0.089]
# [0.678 1. 0.107]
# [0.089 0.107 1. ]]
# semantic search: rank corpus by similarity to a query
query = model.encode("where is the cat?", convert_to_tensor=True)
hits = util.semantic_search(query, emb)[0]
print(hits) # ranks 'cat sits on the mat' highestПулинг против токенных эмбеддингов
Разные слои кодируют разное: нижние — синтаксис, верхние — семантику. [CLS] работает для классификации (при дообучении), но mean-pooling обычно даёт лучший бесплатный вектор предложения. Конкатенация последних 4 слоёв — исходный рецепт извлечения признаков BERT, и он до сих пор хорошо работает для задач уровня токенов вроде NER.
from transformers import AutoTokenizer, AutoModel
import torch
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
model = AutoModel.from_pretrained("bert-base-uncased", output_hidden_states=True)
inputs = tokenizer("I love NLP", return_tensors="pt")
with torch.no_grad():
out = model(**inputs)
# all 13 layers (embedding + 12 transformer layers)
hidden = out.hidden_states # tuple of (1, seq, 768), len 13
print(len(hidden), hidden[0].shape)
# common pooling strategies for a sentence vector:
# 1. [CLS] token of the last layer
cls = hidden[-1][:, 0, :]
# 2. mean-pool over tokens (often better than [CLS])
mask = inputs["attention_mask"].unsqueeze(-1).float()
mean = (hidden[-1] * mask).sum(1) / mask.sum(1)
# 3. concat last 4 layers (rich feature, used in early BERT papers)
cat = torch.cat([hidden[-i][:, 0, :] for i in range(1, 5)], dim=-1)
print(cls.shape, mean.shape, cat.shape) # all (1, 768) except cat (1, 3072)Статические против контекстных
Статические эмбеддинги в 100–300 раз меньше и быстрее BERT, но не различают значения слов. Для задач, где важен контекст (тональность, NER, QA), выигрывают контекстные эмбеддинги. Для чисто пословного сходства, кластеризации большого словаря или работы на CPU в масштабе статические эмбеддинги всё ещё конкурентны — выбирайте по задаче и бюджету.
import numpy as np
from gensim.models import KeyedVectors
from sentence_transformers import SentenceTransformer
# STATIC (Word2Vec/GloVe): same vector regardless of context
w2v = KeyedVectors.load_word2vec_format("glove.6B.100d.w2v.txt")
v1 = w2v["bank"]
v2 = w2v["bank"]
print("static cosine (always 1.0):", np.dot(v1, v2) / (np.linalg.norm(v1)*np.linalg.norm(v2)))
# CONTEXTUAL (BERT): vector depends on surrounding text
bert = SentenceTransformer("all-MiniLM-L6-v2")
from sklearn.metrics.pairwise import cosine_similarity
e_river = bert.encode("sat by the river bank")
e_money = bert.encode("deposited at the bank")
print("contextual cosine of two sentences:", cosine_similarity([e_river], [e_money])[0, 0].round(3))
# trade-offs:
# static: small, fast, fixed vocabulary, OOV-friendly only with FastText
# contextual: large, slower, handles polysemy, needs GPU for speedКлассификация текстов
Pipeline sklearn для текста
Конвейер TfidfVectorizer + LogisticRegression — канонический бейзлайн классификации текстов: быстрый, интерпретируемый, и его трудно обойти без глубокого обучения. Pipeline объединяет предобработку и модель, поэтому те же преобразования применяются при предсказании. class_weight='balanced' помогает при несбалансированных классах. Всегда сообщайте precision/recall по классам, а не только accuracy.
from sklearn.pipeline import Pipeline
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
# X: list of strings, y: labels
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
stratify=y, random_state=42)
clf = Pipeline([
("tfidf", TfidfVectorizer(ngram_range=(1, 2), min_df=2,
sublinear_tf=True, stop_words="english")),
("clf", LogisticRegression(max_iter=1000, class_weight="balanced")),
])
clf.fit(X_train, y_train)
print(classification_report(y_test, clf.predict(X_test)))
# predict on new text
print(clf.predict(["this is a great movie"])) # ['positive']Наивный Байес для текста
Наивный Байес — простейший классификатор текстов: быстрый, работает на крошечных наборах, а «наивное» предположение о независимости слов нарушается, но на практике метод всё равно хорош. MultinomialNB принимает счётчики (или TF-IDF); BernoulliNB — бинарное присутствие. ComplementNB создан специально для несбалансированных классов и часто обходит Multinomial на текстах.
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import Pipeline
clf = Pipeline([
("vec", CountVectorizer()),
("clf", MultinomialNB(alpha=1.0)), # alpha = Laplace smoothing
])
clf.fit(X_train, y_train)
# MultinomialNB assumes word counts -> use CountVectorizer (not TF-IDF)
# alpha=1 (default) adds one to every count -> avoids zero probabilities
# lower alpha (0.1) for less smoothing when you have lots of data
# variants:
# MultinomialNB - counts/TF-IDF (most common for text)
# BernoulliNB - binary features (word present/absent)
# ComplementNB - better on imbalanced text classesЛинейный SVM для текста
LinearSVC часто оказывается лучшим неглубоким классификатором текстов: быстрый, дружественный к разреженным данным и точный на признаках TF-IDF. Минус: нет нативного predict_proba. Оберните в CalibratedClassifierCV, если нужны вероятности (например, для настройки порога). Настраивайте C перебором по сетке; обычно работают значения около 0.1–10.
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.svm import LinearSVC
from sklearn.pipeline import Pipeline
from sklearn.calibration import CalibratedClassifierCV
# LinearSVC is much faster than SVC(kernel='linear') on sparse text
clf = Pipeline([
("tfidf", TfidfVectorizer(sublinear_tf=True)),
("clf", LinearSVC(C=1.0)), # C = inverse regularization
])
# LinearSVC has no predict_proba by default; wrap if you need probabilities
calibrated = CalibratedClassifierCV(LinearSVC(), cv=3)
clf_prob = Pipeline([("tfidf", TfidfVectorizer()),
("clf", calibrated)])
# tune C: smaller C = more regularization (helps with noisy text)
# LinearSVC is often the strongest shallow text classifierДообучение BERT для классификации
Дообучение предобученного BERT/DistilBERT с классификационной головой даёт передовые результаты при нескольких тысячах размеченных примеров. DistilBERT примерно на 40% меньше и быстрее BERT при ~95% качества — отличный выбор по умолчанию. Используйте низкую скорость обучения (2e-5) и 2–4 эпохи; больше эпох ведёт к переобучению. Trainer берёт на себя батчи, смешанную точность и логирование.
from transformers import (AutoTokenizer, AutoModelForSequenceClassification,
TrainingArguments, Trainer)
import torch
model_name = "distilbert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(
model_name, num_labels=3
)
# tokenize the dataset
def tokenize(batch):
return tokenizer(batch["text"], padding="max_length",
truncation=True, max_length=128)
train_ds = dataset["train"].map(tokenize, batched=True)
train_ds.set_format("torch", columns=["input_ids", "attention_mask", "label"])
args = TrainingArguments(
output_dir="./clf",
num_train_epochs=3,
per_device_train_batch_size=16,
learning_rate=2e-5,
eval_strategy="epoch",
)
trainer = Trainer(model=model, args=args,
train_dataset=train_ds, eval_dataset=dataset["test"])
trainer.train()Многометочная классификация
Многометочная классификация отличается от многоклассовой: у каждого примера может быть ноль, одна или много меток. OneVsRestClassifier обучает по одному бинарному классификатору на метку. Используйте micro/macro F1 (а не accuracy): accuracy на пространстве из 100 меток обманчива. Для BERT замените softmax на сигмоиду по каждой метке и используйте BCEWithLogitsLoss.
# multi-label: each document can have MULTIPLE tags
# (e.g. a news article is both 'politics' AND 'economy')
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.multiclass import OneVsRestClassifier
from sklearn.pipeline import Pipeline
from sklearn.metrics import f1_score
# y is a (n_samples, n_labels) binary matrix, NOT a 1-d array
clf = Pipeline([
("tfidf", TfidfVectorizer()),
("clf", OneVsRestClassifier(LogisticRegression(max_iter=1000))),
])
clf.fit(X_train, Y_train) # Y_train: 2D binary array
# predict returns a 2D matrix
pred = clf.predict(X_test)
print(f1_score(Y_test, pred, average="micro"))
# alternatives:
# MultiLabelBinarizer to convert list-of-labels -> 2D matrix
# BinaryRelevance / ClassifierChains from scikit-multilearn
# BERT with sigmoid + BCEWithLogitsLoss (one head per label)Метрики оценки
Accuracy лжёт на несбалансированных данных: детектор спама с 99% отрицательных даёт 99%, всегда предсказывая «не спам». macro F1 трактует все классы одинаково (лучше для дисбаланса), micro F1 подавляется мажоритарным классом, weighted F1 — промежуточный вариант. Всегда смотрите precision/recall по классам, чтобы найти слабые классы перед внедрением.
from sklearn.metrics import (classification_report, confusion_matrix,
f1_score, precision_recall_fscore_support)
y_true = [0, 0, 1, 1, 2, 2]
y_pred = [0, 1, 1, 1, 2, 0]
# per-class precision / recall / F1
print(classification_report(y_true, y_pred, digits=3))
# F1 averaging strategies (multi-class):
# macro : average F1 over classes (treats all classes equally)
# micro : aggregate then compute (dominated by majority class)
# weighted: average weighted by class support
print("macro F1:", f1_score(y_true, y_pred, average="macro"))
print("micro F1:", f1_score(y_true, y_pred, average="micro"))
# confusion matrix
print(confusion_matrix(y_true, y_pred))
# ROC-AUC needs probabilities; for multi-class use roc_auc_score with multi_class='ovr'Анализ тональности
VADER (на лексиконе)
VADER основан на правилах и не требует обучающих данных — идеален для соцсетей (обрабатывает смайлики, CAPS, 'kinda', '!'). compound — рекомендуемая одномерная оценка. Он плохо справляется с сарказмом и тональностью, зависящей от контекста. VADER только для английского; для других языков используйте трансформер или сначала переведите.
import nltk
from nltk.sentiment.vader import SentimentIntensityAnalyzer
nltk.download('vader_lexicon')
sia = SentimentIntensityAnalyzer()
for text in ["I love this!", "This is terrible :(",
"It's okay, not great."]:
scores = sia.polarity_scores(text)
print(f"{text:25} {scores}")
# {'neg': 0.0, 'neu': 0.308, 'pos': 0.692, 'compound': 0.636}
# {'neg': 0.679, 'neu': 0.321, 'pos': 0.0, 'compound': -0.476}
# {'neg': 0.323, 'neu': 0.677, 'pos': 0.0, 'compound': -0.226}
# compound: normalized score in [-1, 1]
# common thresholds: >0.05 positive, <-0.05 negative, else neutralТональность в TextBlob
TextBlob оборачивает лексикон на основе Pattern и за один вызов даёт полярность и субъективность. Субъективность удобна, чтобы отделить фактический текст от оценочного. TextBlob менее устойчив на соцсетях, чем VADER (не обрабатывает смайлики), но проще. Оба — бейзлайны: дообученный трансформер обходит их, когда есть размеченные данные.
from textblob import TextBlob # pip install textblob
for text in ["I love NLP.", "This is the worst experience.",
"The movie was okay."]:
blob = TextBlob(text)
print(f"{text:30} polarity={blob.sentiment.polarity:.2f} "
f"subjectivity={blob.sentiment.subjectivity:.2f}")
# I love NLP. polarity=0.50 subjectivity=0.60
# This is the worst experience. polarity=-0.60 subjectivity=0.75
# The movie was okay. polarity=0.00 subjectivity=0.00
# polarity: [-1, 1] negative to positive
# subjectivity: [0, 1] objective (fact) to subjective (opinion)
# also gives noun phrases, translation, etc.
print(blob.noun_phrases)Тональность на трансформерах
Предобученная модель тональности с Hub даёт продакшен-качество без обучающих данных. Zero-shot pipeline — волшебство для быстрого прототипирования: передайте любые кандидатные метки, и он ранжирует их через NLI. Zero-shot менее точен, чем дообученная модель, но бесценен, когда метки неизвестны или часто меняются.
from transformers import pipeline
# zero-shot: pick any labels you want, no fine-tuning
clf = pipeline("sentiment-analysis",
model="distilbert-base-uncased-finetuned-sst-2-english")
print(clf(["I love this product!", "Worst purchase ever."]))
# [{'label': 'POSITIVE', 'score': 0.9998}, {'label': 'POSITIVE'...}]
# zero-shot classification: works on ANY label set
zero = pipeline("zero-shot-classification",
model="facebook/bart-large-mnli")
print(zero("The battery lasts only an hour.",
candidate_labels=["positive", "negative", "neutral"]))
# {'labels': ['negative', 'neutral', 'positive'], 'scores': [0.95, ...]}Дообученная модель тональности
Дообучение на собственных размеченных данных обходит любую готовую модель тональности, потому что определения меток различаются (5 звёзд против 3 классов против аспектной тональности). Используйте низкую скорость обучения (2e-5), 2–4 эпохи и следите за validation loss на предмет переобучения. Библиотека 'evaluate' содержит стандартные метрики. Сохраняйте модель через trainer.save_model().
from transformers import (AutoTokenizer, AutoModelForSequenceClassification,
Trainer, TrainingArguments)
import evaluate
model_name = "distilbert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
def tokenize(batch):
return tokenizer(batch["text"], truncation=True, padding="max_length")
train_ds = dataset["train"].map(tokenize, batched=True)
train_ds = train_ds.rename_column("label", "labels")
train_ds.set_format("torch")
accuracy = evaluate.load("accuracy")
def compute_metrics(eval_pred):
logits, labels = eval_pred
preds = logits.argmax(axis=-1)
return accuracy.compute(predictions=preds, references=labels)
args = TrainingArguments("sentiment", num_train_epochs=3,
per_device_train_batch_size=16,
eval_strategy="epoch", learning_rate=2e-5)
trainer = Trainer(model=model, args=args, train_dataset=train_ds,
eval_dataset=dataset["test"], compute_metrics=compute_metrics)
trainer.train()Аспектная тональность
Аспектный анализ тональности (ABSA) разбирает отзыв на мнения по каждому аспекту — гораздо полезнее одной оценки документа для обратной связи о продукте. Zero-shot с NLI работает как быстрый прототип; для продакшена дообучите классификатор пар последовательностей (аспект, текст) -> тональность или используйте специализированные библиотеки вроде pyabsa. LLM со структурированными промптами тоже конкурентны.