NLTK, старожил в мире обработки естественного языка на Python, содержит богатейшую коллекцию алгоритмов и готовых моделей. Эта библиотека отлично подходит для образовательных целей и исследовательских задач, позволяя детально изучить каждый этап обработки текста. Spacy — молодой и амбициозный проект, заточенный под промышленное использование, где скорость и эффективность играют решающую роль. Интересный факт: несмотря на кажущуюся конкуренцию, эти библиотеки часто дополняют друг друга. NLTK предоставляет широкие возможности для экспериментов и глубокого анализа, тогда как Spacy обеспечивает высокую производительность в продакшен-среде. Такой тандем позволяет разработчикам выбирать оптимальные инструменты для конкретных задач.
NLTK предлагает обширный набор корпусов текстов и лексиконов, что идеально подходит для академических исследований и обучения моделей. Spacy же выделяется своей архитектурой, оптимизированной для работы с большими объёмами данных, и встроенной поддержкой нейронных сетей. В реальных проектах часто встречается потребность в комбинировании возможностей обеих библиотек. Например, можно использовать NLTK для предварительной обработки текста и создания обучающих данных, а затем применять Spacy для быстрого анализа в production-окружении. Такой подход позволяет получить максимум от обеих технологий.
Одна из сильных сторон этого тандема — гибкость в решении различных задач. Можно начать с простой токенизации текста и постепенно перейти к сложному синтаксическому анализу или извлечению именованных сущностей. При этом обе библиотеки поддерживают множество языков, что делает их универсальным инструментом для международных проектов. Стоит отметить, что выбор между NLTK и Spacy (или их совместным использованием) зависит от конкретной задачи. Для небольших проектов с акцентом на исследование и эксперименты NLTK может оказаться более подходящим выбором. В случае же масштабных промышленных решений Spacy покажет себя с лучшей стороны благодаря оптимизированной производительности.
На практике эти библиотеки часто используются в связке с другими инструментами анализа данных, такими как pandas для обработки структурированных данных или scikit-learn для машинного обучения. Такая экосистема позволяет создавать полноценные решения для анализа текстов, от сбора данных до построения сложных моделей классификации или кластеризации.
Установка и настройка библиотек: типичные проблемы и их решения
Установка NLTK и Spacy может показаться простой задачей, но на практике часто возникают неожиданные сложности. Начнём с базовой установки через pip:
| Python | 1
2
| pip install nltk
pip install spacy |
|
| Python | 1
2
3
4
5
| import nltk
nltk.download('all') # Загружает все данные
# Или выборочно:
nltk.download('punkt') # Только токенизатор
nltk.download('averaged_perceptron_tagger') # Для POS-тэггинга |
|
| Python | 1
2
3
| python -m spacy download en_core_web_sm
# или
python -m spacy download en_core_web_lg |
|
При работе с виртуальными окружениями возникает другая проблема: путаница с путями к установленным моделям. Решение — использовать абсолютные пути или создавать символические ссылки. В Windows это особенно актуально:
| Python | 1
2
3
4
| import spacy
from pathlib import Path
model_path = Path("path/to/models/en_core_web_sm")
nlp = spacy.load(model_path) |
|
| Python | 1
| pip install --user nltk spacy |
|
| Python | 1
2
3
| import spacy
nlp = spacy.load('ru_core_news_sm')
nlp.add_pipe('morph_analyzer', config={'lang': 'ru'}) |
|
| Python | 1
2
| nlp = spacy.load('en_core_web_sm', disable=['ner', 'parser'])
# Отключаем ненужные компоненты для экономии памяти |
|
В Docker-контейнерах установка может занимать много места. Оптимизация:
| Code | 1
2
3
| RUN pip install --no-cache-dir nltk spacy && \
python -m spacy download en_core_web_sm && \
python -m nltk.downloader punkt |
|
При обновлении библиотек стоит проверять совместимость с существующим кодом. Особенно это касается Spacy, где API может меняться между версиями. Хорошая практика — фиксировать версии в requirements.txt:
| Python | 1
2
| spacy==3.5.0
nltk==3.8.1 |
|
Несколько ошибок в runpy.py при использовании spacy
Возникла проблема, нашел в интернете идентичную:
https://github.com/explosion/spaCy/issues/4733... Использование библиотек spacy и textacy
Всем привет, изучаем в институте NLP. Наткнулся на код в интернете, где берется текст из Википедии... считать текст и сделать лемматизацию с spacy
считать текст и сделать лемматизацию с помощью spacy NLTK with python
Привет! Ни у кого вдруг нету решений задач с книги Natural language processing with python? Или...
Сравнение NLTK и Spacy: особенности архитектуры и производительности
Архитектурные различия между NLTK и Spacy определяют их уникальные сильные стороны. NLTK построен по модульному принципу, где каждый компонент можно использовать независимо от других. Такой подход даёт гибкость в исследовательской работе, но может усложнять интеграцию в промышленные системы. Spacy использует монолитную архитектуру с единым конвейером обработки. Все компоненты тесно связаны и оптимизированы для совместной работы. Это ограничивает гибкость, но значительно повышает производительность. В реальных тестах Spacy показывает скорость обработки в 5-10 раз выше, чем NLTK при аналогичных задачах.
Интересное наблюдение из практики: при обработке больших текстовых корпусов (более 1 миллиона документов) Spacy демонстрирует почти линейный рост производительности при увеличении числа ядер процессора. NLTK же начинает существенно замедляться после определённого объёма данных из-за особенностей управления памятью.
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| import time
import spacy
import nltk
from concurrent.futures import ProcessPoolExecutor
def benchmark_spacy(texts):
nlp = spacy.load('en_core_web_sm')
start = time.time()
docs = list(nlp.pipe(texts))
return time.time() - start
def benchmark_nltk(texts):
start = time.time()
for text in texts:
tokens = nltk.word_tokenize(text)
tags = nltk.pos_tag(tokens)
return time.time() - start
# Пример многопроцессорной обработки в Spacy
def process_batch_spacy(texts, n_processes=4):
nlp = spacy.load('en_core_web_sm')
with ProcessPoolExecutor(max_workers=n_processes) as executor:
docs = list(nlp.pipe(texts, n_process=n_processes))
return docs |
|
Что касается потребления памяти, здесь ситуация неоднозначная. NLTK загружает компоненты по требованию, что позволяет экономить память, но может привести к фрагментации. Spacy держит всю модель в памяти постоянно, что ускоряет работу, но требует больше ресурсов:
| Python | 1
2
3
4
5
6
7
8
9
10
| # Оптимизация памяти в Spacy
nlp = spacy.load('en_core_web_sm', disable=['ner', 'parser'])
text = "Sample text for memory optimization"
doc = nlp(text)
# Экономия памяти в NLTK
from nltk.tokenize import word_tokenize
from nltk.tag import pos_tag
tokens = word_tokenize(text)
tags = pos_tag(tokens) |
|
В контексте многоязычной обработки NLTK предоставляет больше инструментов для работы с редкими языками и диалектами. Spacy фокусируется на основных мировых языках, но обеспечивает более качественную обработку благодаря предобученным моделям:
| Python | 1
2
3
4
5
6
7
8
9
10
11
| # Многоязычная обработка в Spacy
nlps = {
'en': spacy.load('en_core_web_sm'),
'de': spacy.load('de_core_news_sm'),
'fr': spacy.load('fr_core_news_sm')
}
def process_multilingual(text, lang):
if lang in nlps:
return nlps[lang](text)
return None |
|
При использовании GPU-ускорения Spacy демонстрирует значительное преимущество благодаря встроенной поддержке CUDA. NLTK не имеет прямой поддержки GPU, хотя может использовать его через интеграцию с другими библиотеками. Интересный факт из реальной практики: при анализе социальных медиа, где тексты короткие и содержат много сленга, NLTK часто показывает более точные результаты благодаря гибкой системе правил. Spacy же лучше работает с формальными текстами, где важна скорость обработки больших объёмов данных.
Токенизация и предобработка текста: практические примеры
Токенизация и предобработка текста — фундаментальные операции в анализе естественного языка. На первый взгляд простые, эти процессы таят в себе множество подводных камней, особенно когда речь идёт о реальных данных с их неидеальной структурой и особенностями. Начнём с базовой токенизации. NLTK предлагает несколько подходов, каждый со своими особенностями:
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| from nltk.tokenize import word_tokenize, sent_tokenize, RegexpTokenizer
text = "Д-р Смит заплатил $50.00 за программу e-mail рассылки... Недорого!"
# Базовая токенизация
tokens = word_tokenize(text)
# ['Д', '-', 'р', 'Смит', 'заплатил', '$', '50.00', 'за', 'программу',
[H2]'e', '-', 'mail', 'рассылки', '...', 'Недорого', '!'][/H2]
# Регулярные выражения для специфических случаев
pattern = r'[A-Za-zА-Яа-я]+(?:-[A-Za-zА-Яа-я]+)*'
regex_tokenizer = RegexpTokenizer(pattern)
custom_tokens = regex_tokenizer.tokenize(text)
# ['Д-р', 'Смит', 'заплатил', 'за', 'программу', 'e-mail', 'рассылки', 'Недорого'] |
|
| Python | 1
2
3
4
5
6
7
8
| import spacy
nlp = spacy.load('ru_core_news_sm')
doc = nlp(text)
# Умная токенизация с сохранением связей
for token in doc:
print(f"{token.text}: {token.pos_} - {token.dep_}") |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| class TechnicalTokenizer:
def __init__(self):
self.special_cases = {
'e-mail': 'email',
'к.т.н.': 'ктн',
'etc.': 'etc'
}
def normalize_text(self, text):
for old, new in self.special_cases.items():
text = text.replace(old, new)
return text
def tokenize(self, text):
text = self.normalize_text(text)
# Дополнительная логика токенизации
return text.split() |
|
| Python | 1
2
3
4
5
6
7
8
9
10
| def process_russian_text(text):
# Нормализация тире и дефисов
text = text.replace('—', '-').replace('–', '-')
# Обработка буквы ё
text = text.replace('ё', 'е')
# Особые случаи
text = text.replace('из-за', 'из_за')
return text |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| from nltk.corpus import stopwords
russian_stops = set(stopwords.words('russian'))
# Умное удаление стоп-слов с сохранением контекста
def smart_remove_stopwords(tokens, min_length=3):
result = []
for i, token in enumerate(tokens):
if token.lower() in russian_stops:
# Проверяем контекст
if i > 0 and i < len(tokens) - 1:
if tokens[i-1].lower() == 'не':
result.append(token)
continue
if len(token) >= min_length:
result.append(token)
return result |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
| import regex as re
def handle_special_chars(text):
emoji_pattern = re.compile("["
u"\U0001F600-\U0001F64F" # эмодзи
u"\U0001F300-\U0001F5FF" # символы и пиктограммы
u"\U0001F680-\U0001F6FF" # транспорт и символы
u"\U0001F1E0-\U0001F1FF" # флаги
"]+", flags=re.UNICODE)
# Заменяем эмодзи на текстовые описания
text = emoji_pattern.sub(r' emoji ', text)
return text |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| from bs4 import BeautifulSoup
import html
def clean_web_text(text):
# Удаление HTML-тегов
soup = BeautifulSoup(text, 'html.parser')
text = soup.get_text()
# Декодирование HTML-сущностей
text = html.unescape(text)
# Обработка URL
url_pattern = r'https?://\S+|www\.\S+'
text = re.sub(url_pattern, ' url ', text)
return text |
|
| Python | 1
2
3
4
5
6
7
8
| from concurrent.futures import ProcessPoolExecutor
from functools import partial
def process_batch(texts, tokenizer, batch_size=1000):
with ProcessPoolExecutor() as executor:
process_func = partial(tokenizer.tokenize)
results = list(executor.map(process_func, texts, chunksize=batch_size))
return results |
|
| Python | 1
2
3
4
5
6
7
8
9
| def handle_compound_words(text):
patterns = {
r'\w+(?:-\w+)+': lambda x: x.group(0).replace('-', '_'), # Составные через дефис
r'[А-Я][а-я]+[А-Я][а-я]+': lambda x: re.sub(r'([а-я])([А-Я])', r'\1_\2', x.group(0)) # CamelCase
}
for pattern, replacement in patterns.items():
text = re.sub(pattern, replacement, text)
return text |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| class ScientificTextProcessor:
def __init__(self):
self.formula_pattern = r'\$.*?\$|\\\[.*?\\\]'
self.citation_pattern = r'\[\d+\]|\(\w+,\s*\d{4}\)'
def extract_formulas(self, text):
formulas = re.findall(self.formula_pattern, text)
text = re.sub(self.formula_pattern, ' formula_placeholder ', text)
return text, formulas
def process_citations(self, text):
citations = re.findall(self.citation_pattern, text)
text = re.sub(self.citation_pattern, ' citation_placeholder ', text)
return text, citations |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| def handle_code_snippets(text):
code_blocks = []
in_code = False
current_block = []
for line in text.split('\n'):
if line.strip().startswith('```'):
in_code = not in_code
if not in_code:
code_blocks.append('\n'.join(current_block))
current_block = []
continue
if in_code:
current_block.append(line)
else:
# Обработка обычного текста
pass
return code_blocks |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| class AbbreviationHandler:
def __init__(self):
self.common_abbr = {
'т.к.': 'так как',
'т.д.': 'так далее',
'т.п.': 'тому подобное',
'др.': 'другие',
'проф.': 'профессор'
}
def expand_abbreviations(self, text):
for abbr, full in self.common_abbr.items():
text = text.replace(abbr, full)
return text |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| def context_aware_tokenization(text, window_size=3):
tokens = text.split()
result = []
for i in range(len(tokens)):
# Получаем контекстное окно
start = max(0, i - window_size)
end = min(len(tokens), i + window_size + 1)
context = tokens[start:end]
# Анализируем текущий токен в контексте
current_token = tokens[i]
if needs_special_handling(current_token, context):
current_token = handle_special_case(current_token, context)
result.append(current_token)
return result |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| def process_dialogue(text):
dialogue_markers = ['—', '–', '-']
quotes = ['«»', '""', '''''']
def find_quote_pairs(text):
stack = []
pairs = []
for i, char in enumerate(text):
if char in '«"'':
stack.append((char, i))
elif char in '»"'' and stack:
start_char, start_idx = stack.pop()
pairs.append((start_idx, i))
return pairs
quote_pairs = find_quote_pairs(text)
# Обработка текста с учётом найденных пар кавычек |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| from langdetect import detect
def language_aware_tokenization(text):
try:
lang = detect(text)
if lang == 'ru':
return process_russian_text(text)
elif lang == 'en':
return process_english_text(text)
else:
return process_default_text(text)
except:
# Fallback на базовую токенизацию
return text.split() |
|
Анализ морфологии и синтаксиса с обеими библиотеками
Морфологический и синтаксический анализ текста — одни из самых сложных задач в обработке естественного языка, особенно для русского языка с его богатой морфологией и свободным порядком слов. NLTK и Spacy предлагают разные подходы к решению этих задач. В NLTK морфологический анализ начинается с определения частей речи (POS-tagging). Вот пример использования стандартного тэггера:
| Python | 1
2
3
4
5
6
| import nltk
from nltk import pos_tag, word_tokenize
text = "Программист быстро написал сложный алгоритм"
tokens = word_tokenize(text)
tagged = pos_tag(tokens, lang='rus') |
|
| Python | 1
2
3
4
5
6
7
8
9
| from nltk.tag import CRFTagger
# Создаём и обучаем CRF-тэггер
tagger = CRFTagger()
# Обучаем на размеченном корпусе
tagger.train('path/to/training/data.txt', 'russian_tagger.crf.tagger')
# Используем обученный тэггер
tagged_text = tagger.tag(tokens) |
|
| Python | 1
2
3
4
5
6
7
| import spacy
nlp = spacy.load('ru_core_news_sm')
doc = nlp("Программист быстро написал сложный алгоритм")
for token in doc:
print(f"{token.text} - {token.pos_} - {token.morph}") |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| class VerbAnalyzer:
def __init__(self):
self.nlp = spacy.load('ru_core_news_sm')
def analyze_verb(self, verb):
doc = self.nlp(verb)
if doc[0].pos_ == "VERB":
return {
'aspect': doc[0].morph.get('Aspect'),
'tense': doc[0].morph.get('Tense'),
'person': doc[0].morph.get('Person'),
'number': doc[0].morph.get('Number')
}
return None |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| from nltk import RecursiveDescentParser
from nltk import CFG
# Определяем грамматику
grammar = CFG.fromstring("""
S -> NP VP
NP -> Det N | N
VP -> V NP | V
Det -> 'the' | 'a'
N -> 'cat' | 'dog'
V -> 'chased' | 'saw'
""")
parser = RecursiveDescentParser(grammar) |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
| def analyze_dependencies(text):
doc = nlp(text)
dependencies = []
for token in doc:
dependencies.append({
'token': token.text,
'dep': token.dep_,
'head': token.head.text,
'children': [child.text for child in token.children]
})
return dependencies |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
| def find_participle_constructions(doc):
participles = []
for token in doc:
if "Participle" in token.morph.get("VerbForm", []):
construction = {
'participle': token.text,
'modifies': token.head.text,
'dependents': [child.text for child in token.children]
}
participles.append(construction)
return participles |
|
| Python | 1
2
3
4
5
6
7
8
9
| def check_agreement(doc):
errors = []
for token in doc:
if token.dep_ == "nsubj" and token.pos_ == "NOUN":
verb = token.head
if verb.pos_ == "VERB":
if token.morph.get("Number") != verb.morph.get("Number"):
errors.append(f"Несогласование в числе: {token.text} - {verb.text}")
return errors |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
| def handle_ellipsis(doc):
reconstructed = []
for sent in doc.sents:
# Ищем пропущенные элементы
subjects = [token for token in sent if token.dep_ == "nsubj"]
if not subjects:
# Пытаемся восстановить подлежащее из контекста
prev_subj = get_previous_subject(sent)
if prev_subj:
reconstructed.append(prev_subj)
reconstructed.extend([token.text for token in sent])
return " ".join(reconstructed) |
|
| Python | 1
2
3
4
5
6
7
8
9
| def smart_lemmatizer(doc):
lemmas = []
for token in doc:
# Учитываем контекст при лемматизации
if token.pos_ == "VERB" and "Participle" in token.morph.get("VerbForm", []):
lemmas.append(token.lemma_ + "_part")
else:
lemmas.append(token.lemma_)
return lemmas |
|
Извлечение именованных сущностей: особенности реализации
Извлечение именованных сущностей (Named Entity Recognition, NER) – одна из ключевых задач в анализе текстов. При всей кажущейся простоте, она таит множество подводных камней, особенно когда речь идёт о русском языке с его морфологической сложностью. Базовый подход с использованием NLTK выглядит так:
| Python | 1
2
3
4
5
6
7
8
9
10
11
| from nltk import ne_chunk, pos_tag, word_tokenize
def extract_entities_nltk(text):
chunks = ne_chunk(pos_tag(word_tokenize(text)))
entities = {}
for chunk in chunks:
if hasattr(chunk, 'label'):
entity_text = ' '.join(c[0] for c in chunk)
entity_type = chunk.label()
entities.setdefault(entity_type, []).append(entity_text)
return entities |
|
| Python | 1
2
3
4
5
6
| import spacy
def extract_entities_spacy(text):
nlp = spacy.load('ru_core_news_sm')
doc = nlp(text)
return {ent.label_: ent.text for ent in doc.ents} |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| class RussianNameExtractor:
def __init__(self):
self.patronymic_endings = ['вич', 'вна', 'ична']
def is_patronymic(self, word):
return any(word.lower().endswith(end) for end in self.patronymic_endings)
def extract_full_names(self, doc):
names = []
current_name = []
for token in doc:
if token.ent_type_ == 'PER' or self.is_patronymic(token.text):
current_name.append(token.text)
else:
if current_name:
names.append(' '.join(current_name))
current_name = []
return names |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| def process_org_names(text):
org_patterns = {
r'ООО\s+["«]([^»"]+)[»"]': 'COMMERCIAL',
r'[П|п]АО\s+["«]([^»"]+)[»"]': 'PUBLIC',
r'[А|а]О\s+["«]([^»"]+)[»"]': 'JOINT_STOCK'
}
found_orgs = {}
for pattern, org_type in org_patterns.items():
matches = re.finditer(pattern, text)
for match in matches:
org_name = match.group(1).strip()
found_orgs[org_name] = org_type
return found_orgs |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| def extract_geo_entities(doc):
geo_entities = []
current_entity = []
for token in doc:
if token.ent_type_ == 'LOC':
if token.i > 0 and doc[token.i - 1].ent_type_ == 'LOC':
current_entity.append(token.text)
else:
if current_entity:
geo_entities.append(' '.join(current_entity))
current_entity = [token.text]
else:
if current_entity:
geo_entities.append(' '.join(current_entity))
current_entity = []
return geo_entities |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| class RussianDateExtractor:
def __init__(self):
self.months = {
'января': 1, 'февраля': 2, 'марта': 3,
'апреля': 4, 'мая': 5, 'июня': 6,
'июля': 7, 'августа': 8, 'сентября': 9,
'октября': 10, 'ноября': 11, 'декабря': 12
}
def extract_dates(self, text):
patterns = [
r'\d{1,2}\s+(?:%s)\s+\d{4}' % '|'.join(self.months.keys()),
r'\d{2}\.\d{2}\.\d{4}',
r'\d{4}-\d{2}-\d{2}'
]
dates = []
for pattern in patterns:
matches = re.finditer(pattern, text)
dates.extend(match.group() for match in matches)
return dates |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| def analyze_entity_context(doc, entity):
context_window = 5
start_idx = max(0, entity.start - context_window)
end_idx = min(len(doc), entity.end + context_window)
context_tokens = doc[start_idx:end_idx]
context_features = {
'prev_tokens': [t.text for t in doc[start_idx:entity.start]],
'next_tokens': [t.text for t in doc[entity.end:end_idx]],
'prev_pos': [t.pos_ for t in doc[start_idx:entity.start]],
'next_pos': [t.pos_ for t in doc[entity.end:end_idx]]
}
return context_features |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| def extract_numerical_entities(text):
patterns = {
'money': r'\d+(?:[\.,]\d+)?\s*(?:руб(?:лей)?|₽|USD|€)',
'percentage': r'\d+(?:[\.,]\d+)?\s*%',
'weight': r'\d+(?:[\.,]\d+)?\s*(?:кг|г|тонн)',
'distance': r'\d+(?:[\.,]\d+)?\s*(?:км|м|см)'
}
entities = {}
for entity_type, pattern in patterns.items():
matches = re.finditer(pattern, text)
entities[entity_type] = [match.group() for match in matches]
return entities |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| class ProfessionalEntityExtractor:
def __init__(self):
self.profession_markers = {
'IT': ['программист', 'разработчик', 'админ'],
'MEDICINE': ['врач', 'хирург', 'терапевт'],
'SCIENCE': ['учёный', 'исследователь', 'профессор']
}
def extract_professional_entities(self, doc):
found_entities = []
for token in doc:
for domain, markers in self.profession_markers.items():
if token.text.lower() in markers:
context = self.get_professional_context(token)
found_entities.append({
'text': token.text,
'domain': domain,
'context': context
})
return found_entities |
|
Векторное представление слов и семантический анализ
Векторные представления слов произвели настоящую революцию в обработке естественного языка. В отличие от классических подходов, где слова представлялись просто как символы, векторные модели позволяют захватить семантические отношения между словами в многомерном пространстве. В NLTK работа с векторными представлениями реализуется через интеграцию с Gensim:
| Python | 1
2
3
4
5
6
7
8
9
| from gensim.models import Word2Vec
sentences = [
['программа', 'работает', 'быстро'],
['код', 'выполняется', 'эффективно']
]
model = Word2Vec(sentences, vector_size=100, window=5, min_count=1)
vector = model.wv['программа'] |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| import spacy
nlp = spacy.load('ru_core_news_lg') # Используем большую модель с векторами
doc = nlp('Python - популярный язык программирования')
# Получаем вектор для слова
python_vector = doc[0].vector
# Находим семантически близкие слова
def find_similar_words(word, nlp, n=5):
query_vector = nlp(word).vector
words_vectors = {w: nlp(w).vector for w in nlp.vocab.strings}
similarities = {}
for word, vector in words_vectors.items():
similarity = np.dot(query_vector, vector) / (np.linalg.norm(query_vector) * np.linalg.norm(vector))
similarities[word] = similarity
return sorted(similarities.items(), key=lambda x: x[1], reverse=True)[:n] |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| class PhraseVectorizer:
def __init__(self, nlp):
self.nlp = nlp
def get_phrase_vector(self, phrase):
doc = self.nlp(phrase)
# Взвешенное среднее векторов слов
vectors = [token.vector * token.prob for token in doc if token.has_vector]
if vectors:
return np.mean(vectors, axis=0)
return None
def compare_phrases(self, phrase1, phrase2):
vec1 = self.get_phrase_vector(phrase1)
vec2 = self.get_phrase_vector(phrase2)
if vec1 is not None and vec2 is not None:
return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))
return 0.0 |
|
| Python | 1
2
3
4
5
6
7
8
9
| def normalize_russian_vectors(text, nlp):
words = []
doc = nlp(text)
for token in doc:
# Приводим слово к начальной форме
if token.has_vector:
normalized = token.lemma_
words.append(normalized)
return words |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| from sklearn.cluster import KMeans
import numpy as np
def cluster_words(word_vectors, n_clusters=5):
kmeans = KMeans(n_clusters=n_clusters)
clusters = kmeans.fit_predict(word_vectors)
word_clusters = {}
for word, cluster_id in zip(words, clusters):
if cluster_id not in word_clusters:
word_clusters[cluster_id] = []
word_clusters[cluster_id].append(word)
return word_clusters |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| def analyze_context_vectors(doc, window_size=2):
context_vectors = {}
for i, token in enumerate(doc):
if token.has_vector:
# Собираем контекстное окно
start = max(0, i - window_size)
end = min(len(doc), i + window_size + 1)
context = doc[start:end]
# Вычисляем контекстный вектор
context_vector = np.mean([t.vector for t in context if t.has_vector], axis=0)
context_vectors[token.text] = context_vector
return context_vectors |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| def semantic_similarity_metrics(vec1, vec2):
# Косинусное расстояние
cosine = np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))
# Евклидово расстояние
euclidean = np.linalg.norm(vec1 - vec2)
# Манхэттенское расстояние
manhattan = np.sum(np.abs(vec1 - vec2))
return {
'cosine': cosine,
'euclidean': euclidean,
'manhattan': manhattan
} |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
| from sklearn.manifold import TSNE
def visualize_word_vectors(word_vectors, words):
tsne = TSNE(n_components=2, random_state=42)
vectors_2d = tsne.fit_transform(word_vectors)
plt.figure(figsize=(12, 8))
for i, word in enumerate(words):
plt.scatter(vectors_2d[i, 0], vectors_2d[i, 1])
plt.annotate(word, (vectors_2d[i, 0], vectors_2d[i, 1]))
plt.show() |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| class IncrementalWordVectors:
def __init__(self, vector_size=100):
self.vector_size = vector_size
self.word_vectors = {}
self.update_count = {}
def update_vectors(self, new_text):
doc = nlp(new_text)
for token in doc:
if token.has_vector:
if token.text not in self.word_vectors:
self.word_vectors[token.text] = token.vector
self.update_count[token.text] = 1
else:
# Инкрементальное обновление
old_count = self.update_count[token.text]
new_count = old_count + 1
self.word_vectors[token.text] = (old_count * self.word_vectors[token.text] + token.vector) / new_count
self.update_count[token.text] = new_count |
|
Создание полноценного приложения для анализа текста
При разработке полноценного приложения для анализа текста важно правильно организовать архитектуру и выбрать подходящие инструменты. Создадим модульное приложение, объединяющее возможности NLTK и Spacy.
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
| from dataclasses import dataclass
from typing import List, Dict, Optional
import nltk
import spacy
from concurrent.futures import ThreadPoolExecutor
@dataclass
class TextAnalysisResult:
entities: List[Dict]
sentiment: float
keywords: List[str]
summary: str
class TextAnalyzer:
def __init__(self):
self.nlp_spacy = spacy.load('ru_core_news_lg')
self.nlp_spacy.add_pipe('sentencizer')
nltk.download('punkt')
nltk.download('averaged_perceptron_tagger')
self._initialize_pipelines()
def _initialize_pipelines(self):
# Настраиваем пайплайны для разных задач
self.ner_pipeline = self.nlp_spacy.pipe(
'ner',
batch_size=1000,
n_process=2
)
def process_text(self, text: str) -> TextAnalysisResult:
with ThreadPoolExecutor() as executor:
entity_future = executor.submit(self._extract_entities, text)
sentiment_future = executor.submit(self._analyze_sentiment, text)
keyword_future = executor.submit(self._extract_keywords, text)
summary_future = executor.submit(self._generate_summary, text)
return TextAnalysisResult(
entities=entity_future.result(),
sentiment=sentiment_future.result(),
keywords=keyword_future.result(),
summary=summary_future.result()
) |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| from functools import lru_cache
import redis
class CachedTextAnalyzer(TextAnalyzer):
def __init__(self):
super().__init__()
self.redis_client = redis.Redis(host='localhost', port=6379)
@lru_cache(maxsize=1000)
def _cached_process(self, text_hash: str) -> TextAnalysisResult:
cached = self.redis_client.get(text_hash)
if cached:
return pickle.loads(cached)
result = super().process_text(text_hash)
self.redis_client.setex(
text_hash,
3600, # Время жизни кэша - 1 час
pickle.dumps(result)
)
return result |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| from fastapi import FastAPI, BackgroundTasks
from pydantic import BaseModel
app = FastAPI()
analyzer = CachedTextAnalyzer()
class TextRequest(BaseModel):
text: str
callback_url: Optional[str]
@app.post("/analyze")
async def analyze_text(request: TextRequest, background_tasks: BackgroundTasks):
def process_and_callback():
result = analyzer.process_text(request.text)
if request.callback_url:
requests.post(request.callback_url, json=result.dict())
background_tasks.add_task(process_and_callback)
return {"status": "processing"} |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| class StreamProcessor:
def __init__(self, chunk_size=1000):
self.chunk_size = chunk_size
self.analyzer = TextAnalyzer()
def process_stream(self, text_iterator):
buffer = []
for chunk in text_iterator:
buffer.append(chunk)
if len(buffer) >= self.chunk_size:
yield self._process_buffer(buffer)
buffer = []
if buffer:
yield self._process_buffer(buffer)
def _process_buffer(self, buffer):
text = ' '.join(buffer)
return self.analyzer.process_text(text) |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| from abc import ABC, abstractmethod
class TextSource(ABC):
@abstractmethod
def get_text(self) -> str:
pass
class FileTextSource(TextSource):
def __init__(self, filepath):
self.filepath = filepath
def get_text(self) -> str:
with open(self.filepath, 'r', encoding='utf-8') as f:
return f.read()
class WebTextSource(TextSource):
def __init__(self, url):
self.url = url
def get_text(self) -> str:
response = requests.get(self.url)
soup = BeautifulSoup(response.text, 'html.parser')
return soup.get_text() |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| from prometheus_client import Counter, Histogram
import time
class MetricsTextAnalyzer(TextAnalyzer):
def __init__(self):
super().__init__()
self.process_time = Histogram(
'text_processing_seconds',
'Time spent processing text'
)
self.processed_chars = Counter(
'processed_characters_total',
'Total number of processed characters'
)
def process_text(self, text: str) -> TextAnalysisResult:
start_time = time.time()
result = super().process_text(text)
self.process_time.observe(time.time() - start_time)
self.processed_chars.inc(len(text))
return result |
|
Экспертная оценка и перспективы развития
NLTK остаётся незаменимым инструментом для исследовательских задач и образования. Его открытая архитектура позволяет глубоко изучать алгоритмы обработки текста, экспериментировать с различными подходами. Spacy же всё больше фокусируется на производительности и интеграции с современными нейросетевыми моделями.
Основной тренд развития — улучшение поддержки многоязычности. Особенно это заметно в работе с морфологически богатыми языками, такими как русский. Новые версии библиотек стали лучше справляться со словоизменением, падежами и другими особенностями сложных языков.
| Python | 1
2
3
4
5
6
7
8
9
10
11
| # Пример улучшенной обработки морфологии
def analyze_morphology_trends(text):
doc = nlp(text)
morphology_stats = defaultdict(int)
for token in doc:
# Анализируем все морфологические признаки
for feature, value in token.morph.items():
morphology_stats[f"{feature}_{value}"] += 1
return dict(morphology_stats) |
|
| Python | 1
2
3
4
5
6
7
8
9
10
11
12
| # Оптимизация моделей для мобильных устройств
class LightweightProcessor:
def __init__(self, max_memory_mb=100):
self.nlp = spacy.load('ru_core_news_sm')
self.memory_limit = max_memory_mb * 1024 * 1024
def process_within_limits(self, text):
if sys.getsizeof(text) > self.memory_limit:
# Обработка текста порциями
chunks = self._split_text(text)
return self._merge_results(chunks)
return self.nlp(text) |
|
Актуальный тренд — улучшение обработки неформальных текстов, сленга и эмодзи. Современные коммуникации часто включают эти элементы, и системы анализа текста должны уметь с ними работать. При этом важно сохранять баланс между гибкостью и точностью анализа. Отдельное внимание уделяется производительности при работе с большими объёмами данных. Новые версии библиотек лучше используют многоядерные процессоры и графические ускорители, что критично для промышленных применений.
| Python | 1
2
3
4
5
6
7
8
9
10
11
| # Оптимизация для больших объёмов данных
def process_large_corpus(texts, batch_size=1000):
with ProcessPoolExecutor() as executor:
futures = []
for i in range(0, len(texts), batch_size):
batch = texts[i:i + batch_size]
future = executor.submit(process_batch, batch)
futures.append(future)
results = [f.result() for f in futures]
return results |
|
Развитие технологий анализа текста открывает новые возможности в различных областях: от автоматического написания документации до систем поддержки принятия решений. При этом важно помнить о этических аспектах и возможных ограничениях технологий обработки естественного языка.
NLTK для обработки русского текста и другие библиотеки
Насколько хорошо nltk обрабатывает русский текст и какие библиотеки стоит подучить что лучше... Nltk определить список стоп-слов исходя из контекста текста и удалить стоп-слова
Текст:
***
Издавна эти обитатели морских глубин наводят ужас на многих людей, о них слагали... NLTK
Знайти максимальное количество прилагательных может подряд употребляться в предложении англмовы.... Как работать с корпусом в nltk?
Добрый день всем! Изучаю nltk. Есть мануалы. Но все равно не могу понять как можно создать свой... [nltk] Байсовский классификатор
Здравствуйте!
Выполняю классификатор:
1) Взял корпус позитивных и отрицательных слов, смешал.... Используя библиотеку NLTK и/или Томита-парсер, реализовать программу
Используя библиотеку NLTK и/или Томита-парсер, реализовать программу, которая будет выводить... Синтаксический разбор предложения с использованием библиотеки NLTK
Синтаксический разбор предложения с использованием библиотеки NLTK (Построение комбинированных... Синтаксический разбор предложения с использованием библиотеки NLTK
Синтаксический разбор предложения с использованием библиотеки NLTK
(Построение комбинированных... Исправить грамматику при работе с библиотекой nltk
помогите,пожалуйста,исправить код для предложения "Мы ездили на машине в лес "
вопрос!
как... Разбор грамматики при работе с nltk
помогите,пожалуйста, разобраться с грамматикой
почему про вводе предложений :
1. Лиза смотрела... Модуль NLTK обновить до последней версии
здравствуйте, всё перепробовал:
# pip install nltk --upgrade обновить nltk
# pip uninstall nltk... Объектно-ориентированный Python - анализ текста в чатах
Задача:
Используя тестовый файл чата , составить программу, которая используя классы будет...
|
