Обработка естественного языка в Python с помощью spaCy

import spacy
 
nlp = spacy.load("en_core_web_sm")
doc = nlp("Gus Proto разрабатывает на Python и интересуется NLP")
 
# Получаем именованные сущности
for entity in doc.ents:
    print(f"{entity.text}: {entity.label_}")
 
# Анализируем синтаксические зависимости
for token in doc:
    print(f"{token.text} --> {token.dep_}")

# Токенизация в spaCy
doc = nlp("Цена акции упала на 4.5% в период с 2018-2020гг.")
print([token.text for token in doc])
# ['Цена', 'акции', 'упала', 'на', '4.5', '%', 'в', 'период', 'с', '2018', '-', '2020', 'гг', '.']

# Проверка версии Python перед установкой
import sys
print(f"Версия Python: {sys.version}")

# Создание виртуального окружения
python -m venv venv
source venv/bin/activate  # На Windows: venv\Scripts\activate
 
# Установка spaCy
pip install spacy
 
# Проверка установки
python -c "import spacy; print(spacy.__version__)"

# Проверка установленной модели
import spacy
# Загрузка русской модели
nlp = spacy.load("ru_core_news_md")
doc = nlp("SpaCy обрабатывает русские тексты с учетом морфологии")
for token in doc:
    print(f"{token.text}: {token.pos_} ({token.lemma_})")

# Частичная загрузка только нужных компонентов
import spacy
nlp = spacy.load("en_core_web_lg", exclude=["parser", "ner"])

import spacy
 
# Проверка загрузки модели
try:
    nlp = spacy.load("en_core_web_sm")
    test_text = "spaCy correctly processes this sentence."
    doc = nlp(test_text)
    
    # Проверка токенизации
    tokens = [token.text for token in doc]
    assert len(tokens) > 3, "Ошибка токенизации"
    
    # Проверка частей речи
    pos_tags = [token.pos_ for token in doc]
    assert all(tag for tag in pos_tags), "Ошибка определения частей речи"
    
    print("Установка выполнена успешно!")
except Exception as e:
    print(f"Возникла проблема при проверке: {e}")

import spacy
from spacy import displacy
 
nlp = spacy.load("ru_core_news_md")
text = "Компания OpenAI разработала модель GPT-4, которая превосходит предыдущие версии."
doc = nlp(text)
 
# Визуализация синтаксического анализа прямо в ячейке Jupyter
displacy.render(doc, style="dep", jupyter=True, options={"distance": 90})
 
# Визуализация именованных сущностей
displacy.render(doc, style="ent", jupyter=True)

import spacy
 
# Проверка доступности GPU
spacy.prefer_gpu()
print(f"GPU доступен: {spacy.require_gpu()}")
 
# Настройка использования GPU для определенных компонентов
nlp = spacy.load("en_core_web_trf")
nlp.to_disk("model_with_gpu_config")
 
config = {
    "nlp": {"batch_size": 128},
    "components": {
        "transformer": {"model": {"@architectures": "spacy-transformers.TransformerModel.v1"}}
    }
}
 
# Применение конфигурации
nlp.config.update(config)

import time
 
texts = ["Пример текста для обработки"] * 1000  # 1000 документов
 
start = time.time()
for doc in nlp.pipe(texts, batch_size=50):
    pass
print(f"Время обработки: {time.time() - start:.2f} сек")

# Загрузка только необходимых компонентов
nlp = spacy.load("en_core_web_lg", disable=["ner", "textcat"])

# Потоковая обработка из файла
with open("large_text_corpus.txt", "r", encoding="utf-8") as f:
    for line in f:
        doc = nlp(line.strip())
        # Обработка по одному документу

# Отключение сохранения данных токенизации
nlp.max_length = 2000000  # Увеличение максимальной длины документа
docs = list(nlp.pipe(texts, disable=["parser", "ner"]))
 
# Сохранение только необходимых атрибутов
from spacy.tokens import DocBin
doc_bin = DocBin(attrs=["LEMMA", "POS"], store_user_data=False)
for doc in docs:
    doc_bin.add(doc)

# Обработка в режиме потоковой передачи с контролем памяти
from tqdm import tqdm
 
results = []
for batch in tqdm(spacy.util.minibatch(texts, size=100)):
    docs = list(nlp.pipe(batch))
    # Извлечение только нужной информации, без сохранения полных Doc-объектов
    batch_results = [{
        "text": doc.text[:50],
        "entities": [(ent.text, ent.label_) for ent in doc.ents]
    } for doc in docs]
    results.extend(batch_results)
    # Явное освобождение памяти
    del docs, batch_results

import spacy
 
nlp = spacy.load("ru_core_news_sm")
text = "SpaCy обрабатывает текст, включая числа (123) и спец-символы!"
doc = nlp(text)
 
for token in doc:
    print(f"{token.i}\t{token.text}")

0   SpaCy
1   обрабатывает
2   текст
3   ,
4   включая
5   числа
6   (
7   123
8   )
9   и
10  спец
11  -
12  символы
13  !

text = "Машинное обучение трансформирует бизнес-процессы компаний."
doc = nlp(text)
 
for token in doc:
    print(f"{token.text:{15}} | {token.pos_:{10}} | {token.dep_:{10}} | {token.head.text}")

Машинное        | ADJ        | amod       | обучение
обучение        | NOUN       | nsubj      | трансформирует
трансформирует  | VERB       | ROOT       | трансформирует
бизнес          | NOUN       | compound   | процессы
              | PUNCT      | punct      | бизнес
процессы        | NOUN       | obj        | трансформирует
компаний        | NOUN       | nmod       | процессы
.               | PUNCT      | punct      | трансформирует

print([token.text for token in doc if not token.is_stop])  # Токены без стоп-слов
print([token.text for token in doc if token.like_num])     # Числовые токены

text = "Microsoft объявила о приобретении GitHub в июне 2018 года за 7.5 миллиардов долларов."
doc = nlp(text)
 
for ent in doc.ents:
    print(f"{ent.text} ({ent.start_char}:{ent.end_char}) — {ent.label_} — {spacy.explain(ent.label_)}")

Microsoft (0:9) — ORG — Компании, агентства, учреждения
GitHub (34:40) — ORG — Компании, агентства, учреждения
в июне 2018 года (41:57) — DATE — Абсолютные или относительные даты
7.5 миллиардов долларов (61:84) — MONEY — Денежные значения, включая валюту

text = "программисты создали алгоритмы, использующие сложные математические модели"
doc = nlp(text)
 
for token in doc:
    print(f"{token.text:{15}} -> {token.lemma_:{15}} | {token.tag_}")

программисты    -> программист     | NOUN__Animacy=Anim|Case=Nom|Number=Plur
создали         -> создать         | VERB__Aspect=Perf|Gender=Plur|Mood=Ind|Tense=Past|VerbForm=Fin
алгоритмы       -> алгоритм        | NOUN__Animacy=Inan|Case=Acc|Number=Plur
...

# Подсчет частотности лемм
from collections import Counter
lemma_freq = Counter([token.lemma_ for token in doc if not token.is_stop and token.is_alpha])
print(lemma_freq.most_common(5))

text = "Искусственный интеллект развивается быстрыми темпами. Многие компании внедряют его решения."
doc = nlp(text)
 
for sent in doc.sents:
    print(f"Предложение: {sent.text}")
    print(f"Корень: {sent.root.text}")
    print(f"Подлежащее: {[w for w in sent if w.dep_ == 'nsubj'][0].text if [w for w in sent if w.dep_ == 'nsubj'] else 'не найдено'}")

from spacy import displacy
 
text = "Нейронные сети анализируют большие объемы данных."
doc = nlp(text)
 
# Визуализация синтаксического дерева
displacy.serve(doc, style="dep")
 
# Визуализация именованных сущностей
displacy.serve(doc, style="ent")

html = displacy.render(doc, style="dep", page=True)
with open("dependency_tree.html", "w", encoding="utf-8") as f:
    f.write(html)

svg = displacy.render(doc, style="dep")
# Конвертация SVG в PNG с помощью cairosvg или другой библиотеки

# Сравнение падежей в русском тексте
text = "Программа обрабатывает текст программы с помощью программы"
doc = nlp(text)
 
for token in doc:
    if token.lemma_ == "программа":
        print(f"{token.text} - {token.morph.get('Case')}")

# Просмотр стоп-слов для русского языка
from spacy.lang.ru.stop_words import STOP_WORDS
print(f"Количество стоп-слов в русском: {len(STOP_WORDS)}")
print(list(STOP_WORDS)[:10])  # Первые 10 стоп-слов
 
# Фильтрация стоп-слов при обработке
text = "Процесс обработки текста требует особого внимания к деталям"
filtered_tokens = [token.text for token in nlp(text) if not token.is_stop]
print(filtered_tokens)

# Комплексная фильтрация токенов
meaningful_tokens = [
    token for token in doc
    if not token.is_stop and not token.is_punct and token.is_alpha
]

# Извлечение субъектно-предикатных пар
text = "Компания разрабатывает новые алгоритмы. Инженеры тестируют систему."
doc = nlp(text)
 
subject_verb_pairs = []
for token in doc:
    if token.dep_ == "nsubj" and token.head.pos_ == "VERB":
        subject = token.text
        verb = token.head.text
        subject_verb_pairs.append((subject, verb))
 
print(subject_verb_pairs)  # [('Компания', 'разрабатывает'), ('Инженеры', 'тестируют')]

# Извлечение прилагательное + существительное
adj_noun_pairs = []
for token in doc:
    if token.pos_ == "NOUN":
        for child in token.children:
            if child.pos_ == "ADJ":
                adj_noun_pairs.append((child.text, token.text))
 
print(adj_noun_pairs)  # [('новые', 'алгоритмы')]

# Сравнение документов
doc1 = nlp("Машинное обучение преобразует бизнес")
doc2 = nlp("Искусственный интеллект меняет компании")
doc3 = nlp("Акции выросли на десять процентов")
 
# Косинусное сходство (от 0 до 1, где 1 = идентичные по смыслу тексты)
print(doc1.similarity(doc2))  # ~0.8 (высокое сходство)
print(doc1.similarity(doc3))  # ~0.3 (низкое сходство)

# Сравнение слов
print(nlp("кошка").similarity(nlp("собака")))  # ~0.7
print(nlp("кошка").similarity(nlp("автомобиль")))  # ~0.2

# Работа со Span-объектами
text = "Конференция по искусственному интеллекту пройдет в Москве"
doc = nlp(text)
 
# Создание произвольного спана
ai_span = doc[3:5]  # "искусственному интеллекту"
print(f"Спан: {ai_span.text}, корень: {ai_span.root.text}")
 
# Слияние токенов с помощью retokenizer
with doc.retokenize() as retokenizer:
    retokenizer.merge(doc[3:5])  # Объединить "искусственному интеллекту" в один токен
 
# После ретокенизации
for token in doc:
    print(token.text)

# Извлечение глагольных фраз
verb_phrases = []
for token in doc:
    if token.pos_ == "VERB":
        phrase = [token.text]
        for child in token.children:
            if child.dep_ in ("dobj", "advmod", "prep"):
                phrase.append(child.text)
        verb_phrases.append(" ".join(phrase))
 
print(verb_phrases)

from spacy.matcher import Matcher, PhraseMatcher, DependencyMatcher
 
nlp = spacy.load("ru_core_news_md")
# Создание экземпляра матчера
matcher = Matcher(nlp.vocab)

# Шаблон для поиска словосочетаний "прилагательное + существительное"
pattern = [
    {"POS": "ADJ"},  # Прилагательное
    {"POS": "NOUN"}  # Существительное
]
 
matcher.add("ADJ_NOUN_PATTERN", [pattern])
doc = nlp("Современные технологии меняют глобальную экономику")
matches = matcher(doc)
 
for match_id, start, end in matches:
    span = doc[start:end]
    print(span.text)  # "Современные технологии", "глобальную экономику"

# Шаблон с квантификаторами
pattern_with_quantifiers = [
    {"POS": "ADJ", "OP": "*"},  # 0 или более прилагательных
    {"POS": "NOUN"},            # Существительное
    {"LEMMA": "и", "OP": "?"},  # Опциональный союз "и"
    {"POS": "NOUN", "OP": "?"}  # Опциональное существительное
]
 
# Доступные операторы:
# "!" - отрицание (не этот токен)
# "?" - опциональный (0 или 1)
# "+" - 1 или более
# "*" - 0 или более

phrase_matcher = PhraseMatcher(nlp.vocab)
terms = ["искусственный интеллект", "машинное обучение", "нейронные сети"]
patterns = [nlp(term) for term in terms]
phrase_matcher.add("AI_TERMS", patterns)
 
text = "Современное машинное обучение использует глубокие нейронные сети."
doc = nlp(text)
matches = phrase_matcher(doc)
 
for match_id, start, end in matches:
    print(f"Найден термин: {doc[start:end]}")

dep_matcher = DependencyMatcher(nlp.vocab)
pattern = [
    # Корневой токен-глагол
    {
        "RIGHT_ID": "verb",
        "RIGHT_ATTRS": {"POS": "VERB"}
    },
    # Прямое дополнение к глаголу
    {
        "LEFT_ID": "verb",
        "REL_OP": ">",
        "RIGHT_ID": "object",
        "RIGHT_ATTRS": {"DEP": "obj"}
    }
]
 
dep_matcher.add("VERB_OBJECT", [pattern])

complex_pattern = [
    {"LEMMA": {"IN": ["разрабатывать", "создавать", "внедрять"]}},
    {"POS": "DET", "OP": "?"},
    {"POS": "ADJ", "OP": "*"},
    {"LOWER": {"NOT_IN": ["проблему", "трудность"]}, "POS": "NOUN"}
]

def on_match(matcher, doc, i, matches):
    match_id, start, end = matches[i]
    span = doc[start:end]
    print(f"Обнаружен паттерн: {span.text}")
 
matcher.add("CUSTOM_PATTERN", [pattern], on_match=on_match)

nlp = spacy.load("ru_core_news_md")  # Убедитесь, что используете модель с векторами
 
# Получение вектора слова
word1 = nlp("компьютер")
word2 = nlp("ноутбук")
word3 = nlp("дерево")
 
# Сравнение векторов
print(f"Сходство компьютер-ноутбук: {word1.similarity(word2):.4f}")  # ~0.8
print(f"Сходство компьютер-дерево: {word1.similarity(word3):.4f}")   # ~0.3
 
# Доступ к сырым векторам
vector = word1.vector  # numpy-массив размерности 300
print(f"Размерность вектора: {vector.shape}")

# Использование модели на базе трансформеров
nlp = spacy.load("ru_core_news_trf")
doc = nlp("Банк принял новые меры безопасности")
 
# Векторы с учетом контекста (слово "банк" имеет вектор с учетом окружения)
for token in doc:
    print(f"{token.text}: {token.vector_norm:.2f}")

docs = [
    nlp("Искусственный интеллект меняет способы ведения бизнеса"),
    nlp("Компании внедряют ИИ для автоматизации процессов"),
    nlp("Цены на нефть упали на мировых рынках")
]
 
# Матрица сходства документов
import numpy as np
similarity_matrix = np.zeros((len(docs), len(docs)))
for i, doc1 in enumerate(docs):
    for j, doc2 in enumerate(docs):
        similarity_matrix[i, j] = doc1.similarity(doc2)
 
print(similarity_matrix)

import gensim
from gensim import corpora
 
# Подготовка данных с помощью spaCy
processed_texts = []
for text in raw_texts:
    doc = nlp(text)
    tokens = [token.lemma_ for token in doc if not token.is_stop and token.is_alpha]
    processed_texts.append(tokens)
 
# Создание тематической модели
dictionary = corpora.Dictionary(processed_texts)
corpus = [dictionary.doc2bow(text) for text in processed_texts]
lda_model = gensim.models.LdaModel(corpus, num_topics=5, id2word=dictionary)

# config.cfg - основной конфигурационный файл
# train.spacy - обучающий набор данных
[H2]dev.spacy - валидационный набор данных[/H2]
 
# Генерация базовой конфигурации
python -m spacy init config config.cfg --lang ru --pipeline ner,textcat
 
# Обучение модели
python -m spacy train config.cfg --output ./model --paths.train train.spacy --paths.dev dev.spacy

# Конвертация размеченных данных в формат spaCy
python -m spacy convert annotations.json ./ --converter json
 
# Создание небольшого набора для тестирования концепции
import spacy
from spacy.tokens import DocBin
 
nlp = spacy.blank("ru")
db = DocBin()
 
# Создание размеченных примеров
for text, annotations in training_data:
    doc = nlp(text)
    for start, end, label in annotations:
        span = doc.char_span(start, end, label=label)
        if span:
            doc.ents = [span]
    db.add(doc)
 
db.to_disk("train.spacy")

# Пакетная обработка документов
texts = ["Пример текста 1", "Пример текста 2", "Пример текста 3"] * 1000
docs = list(nlp.pipe(texts, batch_size=50))
 
# Отключение ненужных компонентов конвейера
docs = list(nlp.pipe(texts, disable=["ner", "textcat"]))
 
# Параллельная обработка с использованием multiprocessing
from joblib import Parallel, delayed
 
def process_text(text):
    doc = nlp(text)
    return [ent.text for ent in doc.ents]
 
results = Parallel(n_jobs=-1)(delayed(process_text)(text) for text in texts)

# Потоковая обработка из файла
from tqdm import tqdm
 
with open("huge_corpus.txt", "r", encoding="utf-8") as f:
    for i, line in enumerate(tqdm(f)):
        if i % 1000 == 0:
            # Сохранение промежуточных результатов
            with open(f"results_{i//1000}.json", "w") as out:
                json.dump(batch_results, out)
            batch_results = []
        
        doc = nlp(line.strip())
        # Извлечение только необходимой информации
        batch_results.append({
            "entities": [(ent.text, ent.label_) for ent in doc.ents]
        })

@spacy.Language.factory("sentiment_analyzer")
class SentimentAnalyzer:
    def __init__(self, nlp, name):
        self.nlp = nlp
        self.name = name
        # Загрузка модели или словаря для анализа тональности
        self.lexicon = {"отлично": 1.0, "ужасно": -1.0, "неплохо": 0.5}
    
    def __call__(self, doc):
        # Вычисление тональности документа
        doc._.sentiment = sum(self.lexicon.get(token.lower_, 0) for token in doc) / len(doc)
        return doc
 
# Регистрация атрибута
spacy.tokens.Doc.set_extension("sentiment", default=None)
 
# Добавление компонента в конвейер
nlp.add_pipe("sentiment_analyzer")
 
# Использование
doc = nlp("Это отличный продукт, хотя доставка была неудобной")
print(f"Тональность: {doc._.sentiment}")

# Загрузка базовой модели
base_nlp = spacy.load("ru_core_news_md")
 
# Создание пустой модели с переносом векторных представлений
nlp = spacy.blank("ru")
nlp.vocab.vectors = base_nlp.vocab.vectors
 
# Настройка конвейера с добавлением только нужных компонентов
pipe_config = {
    "token_vector": {"@architectures": "spacy.StaticVectors.v1", "width": 300},
    "update_vectors": False
}

# Комбинация статистического NER с правилами
ruler = nlp.add_pipe("entity_ruler", before="ner")
patterns = [
    {"label": "ORG", "pattern": "ООО Рога и Копыта"},
    {"label": "PRODUCT", "pattern": [{"LOWER": "iphone"}, {"IS_DIGIT": True}]}
]
ruler.add_patterns(patterns)

from sklearn.ensemble import RandomForestClassifier
import numpy as np
 
# Обучение базового классификатора
clf = RandomForestClassifier()
clf.fit(X_labeled, y_labeled)
 
# Выбор примеров с наименьшей уверенностью для ручной разметки
proba = clf.predict_proba(X_unlabeled)
uncertainty = 1 - np.max(proba, axis=1)
idx_to_annotate = np.argsort(uncertainty)[-10:]  # 10 самых неопределенных примеров

from spacy.pipeline import EntityRecognizer
import random
 
# Создание инкрементального парсера
vocab = spacy.create_vocab(vectors_name="en_core_web_md")
nlp = spacy.blank("ru", vocab=vocab)
ner = EntityRecognizer(nlp.vocab)
 
# Инкрементальное обучение
for batch in batches:
    random.shuffle(batch)
    for text, annotations in batch:
        doc = nlp(text)
        # Разметка сущностей
        for start, end, label in annotations:
            doc.ents = [(start, end, label)]
        ner.update([doc], drop=0.5)

# Динамическая загрузка моделей по определенному языку
def process_multilingual(text, lang):
    if lang not in LOADED_MODELS:
        try:
            LOADED_MODELS[lang] = spacy.load(f"{lang}_core_news_md")
        except OSError:
            # Запасной вариант для неподдерживаемых языков
            LOADED_MODELS[lang] = spacy.blank(lang)
    
    return LOADED_MODELS[lang](text)
 
# Использование
result_en = process_multilingual("This is an English text", "en")
result_ru = process_multilingual("Это русский текст", "ru")

# Установка и загрузка многоязычного трансформера
# pip install spacy-transformers
nlp = spacy.load("xx_ent_wiki_sm")  # Модель для множества языков
 
# Обработка текстов на разных языках
docs = list(nlp.pipe([
    "This is an English document.",
    "Dies ist ein deutsches Dokument.",
    "Это документ на русском языке."
]))

# Установка необходимых компонентов
[H2]pip install spacy-transformers[/H2]
 
# Загрузка модели на основе трансформера
nlp = spacy.load("ru_core_news_trf")
 
# Или создание собственной конфигурации
config = {
    "nlp": {
        "lang": "ru",
        "pipeline": ["transformer", "tagger", "parser", "ner"]
    },
    "components": {
        "transformer": {
            "factory": "transformer",
            "model": {"@architectures": "spacy-transformers.TransformerModel.v3", 
                      "name": "DeepPavlov/rubert-base-cased"}
        }
    }
}

# Получение субтокенов из трансформера
doc = nlp("Трансформеры обеспечивают глубокое понимание контекста")
# Доступ к информации о токенизации трансформера
for token in doc:
    print(f"{token.text}: {token._.trf_alignment}")

from sklearn.cluster import KMeans
import numpy as np
 
# Подготовка корпуса документов
docs = list(nlp.pipe(text_corpus))
# Извлечение векторов документов
doc_vectors = np.array([doc.vector for doc in docs])
 
# Применение кластеризации
kmeans = KMeans(n_clusters=5)
clusters = kmeans.fit_predict(doc_vectors)
 
# Анализ кластеров
for i in range(5):
    cluster_docs = [docs[j] for j in range(len(docs)) if clusters[j] == i]
    most_central = min(cluster_docs, key=lambda d: 
                     np.linalg.norm(d.vector - kmeans.cluster_centers_[i]))
    print(f"Кластер {i}, центральный документ: {most_central.text[:100]}...")

import networkx as nx
import matplotlib.pyplot as plt
from spacy import displacy
 
# Создание графа сущностей
def build_entity_graph(docs):
    G = nx.Graph()
    for doc in docs:
        for ent in doc.ents:
            if ent.label_ in ["PERSON", "ORG", "GPE"]:
                G.add_node(ent.text, type=ent.label_)
                
        # Связь между сущностями, встречающимися в одном документе
        entities = [ent for ent in doc.ents if ent.label_ in ["PERSON", "ORG", "GPE"]]
        for i, ent1 in enumerate(entities):
            for ent2 in entities[i+1:]:
                if G.has_edge(ent1.text, ent2.text):
                    G[ent1.text][ent2.text]['weight'] += 1
                else:
                    G.add_edge(ent1.text, ent2.text, weight=1)
    return G
 
# Визуализация графа с помощью matplotlib и networkx
G = build_entity_graph(docs)
plt.figure(figsize=(12, 12))
pos = nx.spring_layout(G)
nx.draw_networkx(G, pos, with_labels=True, node_size=500)
plt.show()

# Создание корпуса текстов определенного типа
def build_specialized_corpus(texts, criteria):
    nlp = spacy.load("ru_core_news_md")
    selected_texts = []
    
    for text in texts:
        doc = nlp(text)
        # Пример критерия: текст с высокой долей технических терминов
        tech_terms = sum(1 for token in doc if token.is_alpha and 
                        token.lemma_ in tech_vocabulary)
        tech_ratio = tech_terms / len([t for t in doc if t.is_alpha])
        
        if tech_ratio > criteria["min_tech_ratio"]:
            selected_texts.append(text)
    
    return selected_texts

def align_multilingual_entities(text_ru, text_en):
    nlp_ru = spacy.load("ru_core_news_md")
    nlp_en = spacy.load("en_core_web_md")
    
    doc_ru = nlp_ru(text_ru)
    doc_en = nlp_en(text_en)
    
    # Извлечение сущностей из обоих документов
    ents_ru = {ent.text: ent.label_ for ent in doc_ru.ents}
    ents_en = {ent.text: ent.label_ for ent in doc_en.ents}
    
    # Сопоставление сущностей (например, по словарю или нейросети)
    # В реальном сценарии здесь был бы более сложный алгоритм сопоставления
    alignment = {}
    for ru_ent, ru_label in ents_ru.items():
        for en_ent, en_label in ents_en.items():
            if ru_label == en_label and translator.translate(ru_ent, "en") == en_ent:
                alignment[ru_ent] = en_ent
    
    return alignment

@spacy.Language.factory("topic_classifier")
class TopicClassifier:
    def __init__(self, nlp, name):
        self.name = name
        # Загрузка предобученного классификатора
        import joblib
        self.model = joblib.load("topic_classifier.pkl")
        
    def __call__(self, doc):
        # Подготовка признаков
        features = [token.lemma_ for token in doc if not token.is_stop and token.is_alpha]
        # Предсказание темы
        doc._.topic = self.model.predict([' '.join(features)])[0]
        return doc
 
# Регистрация пользовательского атрибута
spacy.tokens.Doc.set_extension("topic", default=None)

# Адаптивный компонент для персонализированной обработки текста
class AdaptiveProcessor:
    def __init__(self, base_model, user_preferences):
        self.nlp = spacy.load(base_model)
        self.user_prefs = user_preferences
        
        # Добавление персонализированного компонента
        @spacy.Language.component("personalize")
        def personalize(doc):
            # Пример: подстройка важности сущностей на основе интересов пользователя
            for ent in doc.ents:
                if ent.label_ in self.user_prefs["interests"]:
                    ent._.importance = 1.5
                else:
                    ent._.importance = 1.0
            return doc
        
        # Регистрация атрибута и компонента
        if not spacy.tokens.Span.has_extension("importance"):
            spacy.tokens.Span.set_extension("importance", default=1.0)
        self.nlp.add_pipe("personalize", last=True)
    
    def process(self, text):
        return self.nlp(text)

import spacy
from spacytextblob.spacytextblob import SpacyTextBlob
 
# Загрузка модели и добавление компонента анализа настроений
nlp = spacy.load("ru_core_news_md")
nlp.add_pipe("spacytextblob")
 
# Анализ примеров отзывов
reviews = [
    "Этот телефон просто восхитительный! Камера отличная, батарея держит весь день.",
    "Качество сборки хорошее, но цена слишком высокая для таких характеристик.",
    "Ужасное обслуживание, больше никогда не воспользуюсь этим сервисом."
]
 
for review in reviews:
    doc = nlp(review)
    # Получение полярности: от -1.0 (негативно) до 1.0 (позитивно)
    polarity = doc._.blob.polarity
    # Получение субъективности: от 0.0 (объективно) до 1.0 (субъективно)
    subjectivity = doc._.blob.subjectivity
    
    sentiment = "позитивный" if polarity > 0.1 else "негативный" if polarity < -0.1 else "нейтральный"
    print(f"Отзыв: {review}")
    print(f"Настроение: {sentiment} (полярность: {polarity:.2f}, субъективность: {subjectivity:.2f})\n")

from sklearn.svm import LinearSVC
import numpy as np
 
# Подготовка обучающей выборки
def preprocess_text(texts, labels):
    docs = list(nlp.pipe(texts))
    features = np.array([doc.vector for doc in docs])  # Используем векторы документов из spaCy
    return features, np.array(labels)
 
# Обучение классификатора
X_train, y_train = preprocess_text(
    ["Отличный продукт", "Ужасное качество", "Не рекомендую"],
    ["positive", "negative", "negative"]
)
classifier = LinearSVC()
classifier.fit(X_train, y_train)
 
# Классификация нового отзыва
new_review = "Продукт работает стабильно, но есть недочёты"
new_features = nlp(new_review).vector.reshape(1, -1)
prediction = classifier.predict(new_features)[0]
print(f"Предсказанное настроение: {prediction}")

def extract_article_info(text):
    doc = nlp(text)
    
    # Извлечение основных тем (существительные фразы)
    topics = [chunk.text for chunk in doc.noun_chunks 
              if not any(token.is_stop for token in chunk) and len(chunk) > 1]
    
    # Извлечение ключевых действий (глаголы с дополнениями)
    actions = []
    for token in doc:
        if token.pos_ == "VERB" and not token.is_stop:
            # Ищем связанные с глаголом объекты
            objects = [child.text for child in token.children 
                       if child.dep_ in ("dobj", "obj", "iobj")]
            if objects:
                actions.append(f"{token.lemma_} {' '.join(objects)}")
    
    # Извлечение именованных сущностей
    entities = {ent.text: ent.label_ for ent in doc.ents}
    
    # Выделение временных маркеров
    dates = [ent.text for ent in doc.ents if ent.label_ == "DATE"]
    
    return {
        "topics": list(set(topics))[:5],  # Top 5 уникальных тем
        "actions": actions[:3],  # Top 3 ключевых действия
        "entities": entities,
        "dates": dates
    }
 
# Пример использования
news_text = """
Компания SpaceX успешно запустила ракету Falcon 9 с 60 спутниками Starlink на борту 
18 марта 2023 года. Запуск был осуществлен с космодрома на мысе Канаверал во Флориде. 
Это уже пятый запуск системы Starlink в этом году. Илон Маск, генеральный директор SpaceX, 
подтвердил успешное развертывание спутников на низкой околоземной орбите.
"""
 
info = extract_article_info(news_text)
print("Темы статьи:", info["topics"])
print("Ключевые действия:", info["actions"])
print("Упомянутые сущности:", info["entities"])
print("Даты:", info["dates"])

from collections import Counter
import math
 
def generate_tags(text, num_tags=5):
    doc = nlp(text)
    
    # Подсчет частотности всех значимых слов
    word_freq = Counter()
    for token in doc:
        if not token.is_stop and not token.is_punct and token.is_alpha:
            word_freq[token.lemma_] += 1
    
    # Определение ключевых фраз на основе синтаксических связей
    noun_chunks = list(doc.noun_chunks)
    chunk_counts = Counter()
    for chunk in noun_chunks:
        # Фильтрация чанков: удаление стоп-слов в начале и фильтрация коротких чанков
        filtered_chunk = ' '.join([token.lemma_ for token in chunk 
                                  if not token.is_stop or token.i != chunk.start])
        if filtered_chunk and len(filtered_chunk.split()) > 1:
            chunk_counts[filtered_chunk] += 1
    
    # Вычисление оценки для каждого потенциального тега
    tag_scores = {}
    # Оценка отдельных слов
    for word, count in word_freq.items():
        # TF (term frequency) с нормализацией по длине документа
        tf = count / len(doc)
        # Предполагаемая оценка IDF (в реальном приложении вычислялась бы по корпусу)
        presumed_idf = math.log(1000 / (count + 1)) + 1
        tag_scores[word] = tf * presumed_idf
    
    # Оценка фраз (выше, чем отдельных слов)
    for chunk, count in chunk_counts.items():
        chunk_words = chunk.split()
        if len(chunk_words) > 1:
            # Повышенный вес для многословных фраз
            tag_scores[chunk] = (count / len(noun_chunks)) * 2.5
    
    # Дополнительный бонус для именованных сущностей
    for ent in doc.ents:
        if ent.text.lower() in tag_scores:
            tag_scores[ent.text.lower()] *= 1.5
        else:
            tag_scores[ent.text.lower()] = 1.5
    
    # Выбор лучших тегов
    best_tags = sorted(tag_scores.items(), key=lambda x: x[1], reverse=True)[:num_tags]
    return [tag for tag, _ in best_tags]
 
# Пример использования
article = """
Искусственный интеллект трансформирует медицинскую диагностику. Глубокие нейронные сети 
теперь могут анализировать рентгеновские снимки с точностью, сравнимой с опытными радиологами. 
Системы машинного обучения помогают выявлять редкие заболевания на ранних стадиях, 
что критически важно для успешного лечения. Компании Google Health и IBM Watson активно 
разрабатывают алгоритмы для помощи врачам. Однако специалисты предупреждают, что ИИ 
должен дополнять работу медиков, а не заменять их полностью.
"""
 
tags = generate_tags(article)
print(f"Предлагаемые теги: {tags}")

def classify_text_topic(text):
    doc = nlp(text)
    
    # Словари ключевых слов для каждой категории
    categories = {
        "технологии": ["технология", "инновация", "гаджет", "робот", "искусственный интеллект", 
                     "программное обеспечение", "алгоритм", "интернет", "компьютер"],
        "спорт": ["чемпионат", "матч", "игра", "команда", "спортсмен", "тренер", "турнир", 
                "соревнование", "победа", "медаль"],
        "экономика": ["рынок", "инвестиция", "акция", "компания", "бизнес", "экономический", 
                     "финансовый", "прибыль", "бюджет", "инфляция"]
    }
    
    # Лемматизация текста и удаление стоп-слов
    lemmas = [token.lemma_ for token in doc if not token.is_stop and token.is_alpha]
    
    # Подсчет совпадений с ключевыми словами для каждой категории
    scores = {}
    for category, keywords in categories.items():
        # Базовый скоринг: подсчет совпадений лемм
        scores[category] = sum(lemma in keywords for lemma in lemmas)
        
        # Учет именованных сущностей, релевантных для категории
        for ent in doc.ents:
            if category == "технологии" and ent.label_ == "ORG" and any(kw in ent.text.lower() for kw in ["tech", "технолог"]):
                scores[category] += 2
            elif category == "спорт" and ent.label_ == "EVENT" and any(kw in ent.text.lower() for kw in ["турнир", "чемпионат"]):
                scores[category] += 2
            elif category == "экономика" and ent.label_ == "ORG" and any(kw in ent.text.lower() for kw in ["банк", "корпорация"]):
                scores[category] += 2
                
        # Использование векторного сходства для улучшения оценки
        category_vec = nlp(category).vector
        doc_vec = doc.vector
        # Нормализованное косинусное сходство (-1 до 1) масштабируем до (0 до 2)
        similarity_boost = (doc.similarity(nlp(category)) + 1)
        scores[category] *= similarity_boost
    
    # Определение наиболее вероятной категории
    predicted_category = max(scores.items(), key=lambda x: x[1])
    
    # Если нет явного лидера, возвращаем "неопределенно"
    if predicted_category[1] == 0 or (len(scores) > 1 and 
       predicted_category[1] / sum(scores.values()) < 0.4):
        return "неопределенно", scores
    
    return predicted_category[0], scores
 
# Примеры новостей для классификации
news_samples = [
    "Apple представила новый iPhone с улучшенной камерой и процессором A16.",
    "Сборная России по футболу проиграла в матче отборочного этапа чемпионата мира.",
    "Центральный банк повысил ключевую ставку до 8% годовых для сдерживания инфляции."
]
 
for news in news_samples:
    category, scores = classify_text_topic(news)
    print(f"Новость: {news}")
    print(f"Категория: {category}")
    print(f"Оценки: {scores}\n")

class ContextualChatbot:
    def __init__(self):
        self.nlp = spacy.load("ru_core_news_md")
        self.product_catalog = {
            "смартфон X1": {"цена": "30000 руб.", "доступность": "в наличии", 
                          "характеристики": "8GB RAM, 128GB память, камера 48MP"},
            "ноутбук Pro": {"цена": "75000 руб.", "доступность": "предзаказ", 
                          "характеристики": "i7, 16GB RAM, 512GB SSD, 15.6\" экран"},
            "наушники TWS": {"цена": "6500 руб.", "доступность": "в наличии", 
                           "характеристики": "Bluetooth 5.0, шумоподавление, 30ч работы"}
        }
        self.context = {"last_product": None, "last_attribute": None}
        
    def process_query(self, text):
        doc = self.nlp(text)
        
        # Определение намерения пользователя
        intent = self._identify_intent(doc)
        
        # Извлечение продукта и атрибута из запроса
        product = self._extract_product(doc) or self.context["last_product"]
        attribute = self._extract_attribute(doc) or self.context["last_attribute"]
        
        # Обновление контекста
        if product:
            self.context["last_product"] = product
        if attribute:
            self.context["last_attribute"] = attribute
            
        # Формирование ответа
        if intent == "приветствие":
            return "Здравствуйте! Чем могу помочь?"
        
        elif intent == "запрос_информации" and product and attribute:
            if product in self.product_catalog and attribute in self.product_catalog[product]:
                return f"{product}: {attribute} - {self.product_catalog[product][attribute]}"
            else:
                return f"Извините, у меня нет информации о {attribute} для {product}."
                
        elif intent == "запрос_информации" and product:
            return f"Что конкретно вас интересует о {product}? Доступны: цена, доступность, характеристики."
            
        else:
            return "Извините, не могу понять ваш запрос. Попробуйте спросить о конкретном продукте."
    
    def _identify_intent(self, doc):
        greeting_tokens = ["привет", "здравствуй", "добрый", "день", "утро"]
        info_tokens = ["сколько", "стоит", "цена", "характеристики", "когда", "где", "как"]
        
        # Проверка на приветствие
        if any(token.lemma_.lower() in greeting_tokens for token in doc):
            return "приветствие"
            
        # Проверка на запрос информации
        if any(token.lemma_.lower() in info_tokens for token in doc) or doc.text.endswith("?"):
            return "запрос_информации"
            
        return "неопределенно"
    
    def _extract_product(self, doc):
        for product in self.product_catalog:
            if product.lower() in doc.text.lower():
                return product
        return None
    
    def _extract_attribute(self, doc):
        attribute_map = {
            "цена": ["цена", "стоимость", "стоит"],
            "доступность": ["наличие", "доступность", "купить", "заказать"],
            "характеристики": ["характеристики", "параметры", "спецификации"]
        }
        
        for attr, keywords in attribute_map.items():
            if any(keyword in doc.text.lower() for keyword in keywords):
                return attr
        return None
 
# Пример использования
bot = ContextualChatbot()
queries = [
    "Привет!",
    "Сколько стоит смартфон X1?",
    "А какие у него характеристики?",
    "Что насчет ноутбука Pro?",
    "Он доступен сейчас?"
]
 
for query in queries:
    response = bot.process_query(query)
    print(f"Пользователь: {query}")
    print(f"Бот: {response}\n")

def summarize_text(text, num_sentences=3):
    nlp = spacy.load("ru_core_news_md")
    doc = nlp(text)
    
    # Разбиение на предложения
    sentences = list(doc.sents)
    
    # Расчет важности предложений
    sentence_scores = {}
    for sent in sentences:
        # Фильтрация стоп-слов и знаков препинания
        words = [token for token in sent if not token.is_stop and not token.is_punct]
        
        # Оценка на основе частотности слов в документе
        word_freq = {}
        for token in doc:
            if not token.is_stop and not token.is_punct and token.is_alpha:
                word = token.lemma_.lower()
                if word in word_freq:
                    word_freq[word] += 1
                else:
                    word_freq[word] = 1
        
        # Вычисление оценки предложения
        score = sum(word_freq.get(token.lemma_.lower(), 0) for token in words)
        
        # Нормализация по длине предложения
        if len(words) > 0:
            score = score / len(words)
            
        # Бонус для предложений с именованными сущностями
        ent_bonus = sum(1 for _ in sent.ents) * 0.5
        score += ent_bonus
        
        # Бонус для предложений в начале документа
        position_bonus = 1.0 / (1 + sentences.index(sent) * 0.1)
        score *= position_bonus
        
        sentence_scores[sent] = score
    
    # Отбор предложений с наивысшей оценкой
    summary_sentences = sorted(sentence_scores.items(), key=lambda x: x[1], reverse=True)[:num_sentences]
    
    # Сортировка предложений по их порядку в оригинальном тексте
    summary_sentences.sort(key=lambda x: sentences.index(x[0]))
    
    # Формирование резюме
    summary = " ".join([sent.text for sent, _ in summary_sentences])
    return summary
 
# Пример использования
article = """
Исскуственный интеллект трансформирует сферу образования во всём мире. Новые системы 
позволяют создавать персонализированные учебные программы, адаптированные под темп 
и стиль обучения каждого ученика. Учителя получают инструменты для автоматической 
проверки заданий и анализа прогресса студентов. В некоторых странах уже запущены 
пилотные программы по внедрению ИИ-ассистентов в школах. Однако критики указывают 
на риски уменьшения социального взаимодействия и возможного увеличения неравенства 
в доступе к качественному образованию. Исследования показывают, что наиболее эффективным 
является сбалансированный подход, при котором технологии дополняют, а не заменяют 
традиционные методы обучения. Эксперты прогнозируют, что к 2030 году ИИ станет 
неотъемлемой частью образовательного процесса в большинстве развитых стран.
"""
 
summary = summarize_text(article, num_sentences=2)
print(f"Резюме:\n{summary}")