Автоматический анализ текста на Python: от токенизации до инсайтов

import nltk
nltk.download('punkt')
nltk.download('stopwords')

from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords

text = "Python позволяет эффективно анализировать большие объемы текстовых данных."
tokens = word_tokenize(text)
stop_words = set(stopwords.words('russian'))
filtered_tokens = [word for word in tokens if word.lower() not in stop_words]

print(filtered_tokens)
# Вывод: ['Python', 'позволяет', 'эффективно', 'анализировать', 'большие', 'объемы', 'текстовых', 'данных', '.']

import spacy

nlp = spacy.load("ru_core_news_sm")
doc = nlp("Python позволяет эффективно анализировать большие объемы текстовых данных.")

# Токенизация и удаление стоп-слов
tokens = [token.text for token in doc if not token.is_stop]
print(tokens)

from textblob import TextBlob

blob = TextBlob("Python позволяет эффективно анализировать большие объемы текстовых данных.")
print(blob.words)
print(blob.noun_phrases)

# NLTK
from nltk.tokenize import sent_tokenize, word_tokenize

text = "Python — мощный инструмент. Он отлично подходит для анализа текста!"
sentences = sent_tokenize(text)
words = word_tokenize(text)

print(sentences)
# ['Python — мощный инструмент.', 'Он отлично подходит для анализа текста!']

# spaCy
import spacy
nlp = spacy.load("ru_core_news_sm")
doc = nlp(text)

sentences_spacy = [sent.text for sent in doc.sents]
words_spacy = [token.text for token in doc]

# NLTK
from nltk.corpus import stopwords

stop_words = set(stopwords.words('russian'))
filtered_words = [word for word in words if word.lower() not in stop_words]

# spaCy
filtered_words_spacy = [token.text for token in doc if not token.is_stop]

# NLTK
from nltk.stem import WordNetLemmatizer
nltk.download('wordnet')

lemmatizer = WordNetLemmatizer()
lemmatized_words = [lemmatizer.lemmatize(word) for word in words]

# spaCy
lemmatized_words_spacy = [token.lemma_ for token in doc]

# NLTK
from nltk.stem.porter import PorterStemmer

stemmer = PorterStemmer()
stemmed_words = [stemmer.stem(word) for word in words]

import spacy
import re
from string import punctuation

def preprocess_text(text):
# Удаление лишних пробелов и специальных символов
text = re.sub(r'\s+', ' ', text)
text = re.sub(r'[^\w\s]', '', text)

# Обработка с помощью spaCy
nlp = spacy.load("ru_core_news_sm")
doc = nlp(text.lower())

# Фильтрация и лемматизация
tokens = [token.lemma_ for token in doc 
if not token.is_stop 
and not token.is_punct 
and token.text.strip()]

return tokens

sample = "Python — это высокоуровневый язык программирования общего назначения. Он активно используется для анализа текстов!"
processed = preprocess_text(sample)
print(processed)
# ['python', 'высокоуровневый', 'язык', 'программирование', 'общий', 'назначение', 'активно', 'использоваться', 'анализ', 'текст']

# Использование TextBlob для простого анализа тональности
from textblob import TextBlob

text = "Этот продукт превзошел все мои ожидания. Настоятельно рекомендую!"
blob = TextBlob(text)
# TextBlob работает лучше всего с английским, поэтому для русского текста может потребоваться перевод
sentiment = blob.sentiment
print(f"Полярность: {sentiment.polarity}, Субъективность: {sentiment.subjectivity}")
# Полярность: 0.8, Субъективность: 0.75

# Использование Dostoevsky для анализа тональности русского текста
from dostoevsky.tokenization import RegexTokenizer
from dostoevsky.models import FastTextSocialNetworkModel

tokenizer = RegexTokenizer()
model = FastTextSocialNetworkModel(tokenizer=tokenizer)

text = ["Этот продукт превзошел все мои ожидания. Настоятельно рекомендую!"]
results = model.predict(text)

for text, sentiment in zip(text, results):
print(sentiment)
# {'negative': 0.0012, 'positive': 0.9823, 'neutral': 0.0165}

# Классификация текста с использованием scikit-learn
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import Pipeline
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# Пример данных
texts = [
"Python отлично подходит для анализа данных и машинного обучения",
"Новый фреймворк обеспечивает высокую производительность веб-приложений",
"Методы обработки естественного языка улучшают понимание текста",
"Современные библиотеки упрощают разработку веб-приложений",
"Алгоритмы машинного обучения позволяют автоматизировать классификацию"
]

labels = ['ML', 'Web', 'NLP', 'Web', 'ML']

# Разделение данных
X_train, X_test, y_train, y_test = train_test_split(
texts, labels, test_size=0.2, random_state=42
)

# Создание пайплайна
text_clf = Pipeline([
('tfidf', TfidfVectorizer()),
('clf', MultinomialNB()),
])

# Обучение
text_clf.fit(X_train, y_train)

# Проверка на тестовых данных
predictions = text_clf.predict(X_test)
print(classification_report(y_test, predictions))

# Пример использования трансформеров для классификации текста
from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Загрузка предобученной модели и токенизатора
tokenizer = AutoTokenizer.from_pretrained("DeepPavlov/rubert-base-cased")
model = AutoModelForSequenceClassification.from_pretrained("DeepPavlov/rubert-base-cased")

# Подготовка входных данных
text = "Python отлично подходит для анализа текста"
inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True, max_length=512)

# Получение предсказания
with torch.no_grad():
outputs = model(**inputs)
predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)

# Вывод результатов
print(predictions)

# Использование TF-IDF для выделения ключевых слов
from sklearn.feature_extraction.text import TfidfVectorizer

corpus = [
"Python — универсальный язык программирования высокого уровня.",
"Python активно используется для анализа данных и машинного обучения.",
"Обработка естественного языка — одно из применений Python."
]

vectorizer = TfidfVectorizer(max_features=10)
X = vectorizer.fit_transform(corpus)
feature_names = vectorizer.get_feature_names_out()

for i, doc in enumerate(corpus):
# Получаем индексы наиболее важных слов для текущего документа
tfidf_sorting = X.getrow(i).toarray().argsort()[0][::-1]
top_n = 3 # топ-3 ключевых слова
top_words = [feature_names[j] for j in tfidf_sorting[:top_n]]

print(f"Документ {i+1}: {top_words}")

# Документ 1: ['программирования', 'высокого', 'уровня']
# Документ 2: ['машинного', 'данных', 'анализа']
# Документ 3: ['обработка', 'естественного', 'языка']

import spacy

nlp = spacy.load("ru_core_news_sm")
text = "Сергей Брин и Ларри Пейдж основали Google в 1998 году в Калифорнии."
doc = nlp(text)

for ent in doc.ents:
print(f"Сущность: {ent.text}, Тип: {ent.label_}")

# Сущность: Сергей Брин, Тип: PER
# Сущность: Ларри Пейдж, Тип: PER
# Сущность: Google, Тип: ORG
# Сущность: 1998 году, Тип: DATE
# Сущность: Калифорнии, Тип: LOC

import spacy
from collections import Counter

nlp = spacy.load("ru_core_news_sm")
text = """
Python — это язык программирования, который часто используется в анализе данных,
машинном обучении, веб-разработке и автоматизации. Библиотеки, такие как NumPy, 
Pandas и Scikit-learn, делают Python мощным инструментом для обработки данных.
"""

doc = nlp(text)

# Собираем только существительные и именованные сущности
domain_terms = [chunk.text for chunk in doc.noun_chunks]
domain_terms += [ent.text for ent in doc.ents]

# Считаем частоту
term_counter = Counter(domain_terms)
most_common = term_counter.most_common(5)
print("Наиболее часто встречающиеся термины:")
for term, count in most_common:
print(f"{term}: {count}")

# Наиболее часто встречающиеся термины:
# Python: 2
# язык программирования: 1
# анализе данных: 1
# машинном обучении: 1
# веб-разработке: 1

# Простое извлекающее суммирование с помощью nltk
import nltk
from nltk.corpus import stopwords
from nltk.tokenize import sent_tokenize, word_tokenize
from nltk.probability import FreqDist
import heapq

def summarize(text, n_sentences=3):
# Загрузка необходимых ресурсов
nltk.download('stopwords')
nltk.download('punkt')

# Предобработка
stop_words = set(stopwords.words('russian'))
sentences = sent_tokenize(text)

# Расчет частоты слов
word_frequencies = {}
for word in word_tokenize(text.lower()):
if word not in stop_words and word.isalnum():
if word not in word_frequencies:
word_frequencies[word] = 1
else:
word_frequencies[word] += 1

# Нормализация частот
max_frequency = max(word_frequencies.values())
for word in word_frequencies:
word_frequencies[word] = word_frequencies[word] / max_frequency

# Расчет весов предложений
sentence_scores = {}
for i, sentence in enumerate(sentences):
for word in word_tokenize(sentence.lower()):
if word in word_frequencies:
if i not in sentence_scores:
sentence_scores[i] = word_frequencies[word]
else:
sentence_scores[i] += word_frequencies[word]

# Выбор топ-N предложений
summary_sentences = heapq.nlargest(n_sentences, sentence_scores, key=sentence_scores.get)
summary = [sentences[i] for i in sorted(summary_sentences)]

return ' '.join(summary)

long_text = """
Python — высокоуровневый язык программирования общего назначения. Стандартная библиотека 
включает большой объём полезных функций. Python поддерживает несколько парадигм программирования, 
в том числе структурное, объектно-ориентированное, функциональное, императивное и аспектно-ориентированное.
Язык обладает чётким и последовательным синтаксисом, продуманной модульностью и масштабируемостью.
В области машинного обучения и анализа данных Python является одним из самых популярных языков.
Библиотеки NumPy, Pandas и Scikit-learn предоставляют мощные инструменты для работы с данными.
"""

summary = summarize(long_text, 2)
print(summary)
# Python — высокоуровневый язык программирования общего назначения. В области машинного обучения и анализа данных Python является одним из самых популярных языков.

# Использование BERT для извлечения ответов на вопросы
from transformers import pipeline

question_answerer = pipeline("question-answering", model="deepset/roberta-base-squad2")

context = """
Python — высокоуровневый язык программирования, созданный Гвидо ван Россумом в 1991 году.
Он широко используется в анализе данных, машинном обучении, веб-разработке и автоматизации.
"""

question = "Кто создал Python?"
result = question_answerer(question=question, context=context)
print(f"Ответ: {result['answer']}, Уверенность: {result['score']:.2f}")
# Ответ: Гвидо ван Россумом, Уверенность: 0.92

from wordcloud import WordCloud
import matplotlib.pyplot as plt
from collections import Counter
import nltk
from nltk.corpus import stopwords

nltk.download('stopwords')

def generate_wordcloud(text):
# Предобработка текста
stop_words = set(stopwords.words('russian'))
words = [word.lower() for word in nltk.word_tokenize(text) 
if word.isalpha() and word.lower() not in stop_words]

# Подсчет частоты слов
word_freq = Counter(words)

# Создание облака слов
wordcloud = WordCloud(width=800, height=400, 
background_color='white',
max_words=100).generate_from_frequencies(word_freq)

# Отображение облака
plt.figure(figsize=(10, 6))
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')
plt.title('Облако слов')
plt.show()

# Пример использования
text = """
Python является одним из наиболее популярных языков программирования для обработки текста.
Его богатая экосистема библиотек позволяет эффективно решать задачи анализа естественного языка,
машинного обучения и извлечения информации из неструктурированных текстовых данных.
"""

generate_wordcloud(text)

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

def plot_word_frequencies(text, top_n=10):
# Предобработка и подсчет частоты
words = [word.lower() for word in nltk.word_tokenize(text) 
if word.isalpha() and word.lower() not in stopwords.words('russian')]
word_freq = Counter(words)

# Преобразование в DataFrame для визуализации
df = pd.DataFrame(word_freq.most_common(top_n), columns=['Слово', 'Частота'])

# Создание горизонтальной диаграммы
plt.figure(figsize=(10, 6))
sns.barplot(x='Частота', y='Слово', data=df)
plt.title(f'Топ-{top_n} слов по частоте')
plt.tight_layout()
plt.show()

plot_word_frequencies(text, top_n=8)

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from textblob import TextBlob
import numpy as np
from datetime import datetime, timedelta

# Создадим пример данных – отзывы с датами
np.random.seed(42)
n_reviews = 50
start_date = datetime(2023, 1, 1)

reviews = []
for i in range(n_reviews):
date = start_date + timedelta(days=i)
# Генерируем случайный текст для примера
sentiment = np.random.choice(['positive', 'neutral', 'negative'], 
p=[0\.5, 0.3, 0.2])

if sentiment == 'positive':
text = "Отличный продукт! Очень доволен покупкой."
elif sentiment == 'neutral':
text = "Нормальный продукт, соответствует цене."
else:
text = "Разочарован качеством. Не рекомендую."

# Вычисляем полярность с помощью TextBlob
polarity = TextBlob(text).sentiment.polarity

reviews.append({
'date': date,
'text': text,
'actual_sentiment': sentiment,
'polarity': polarity
})

# Создаем DataFrame
df = pd.DataFrame(reviews)
df['week'] = df['date'].dt.isocalendar().week

# Агрегируем данные по неделям
weekly_sentiment = df.groupby('week')['polarity'].mean().reset_index()

# Визуализация изменения тональности по времени
plt.figure(figsize=(12, 6))
sns.lineplot(x='week', y='polarity', data=weekly_sentiment, marker='o')
plt.axhline(y=0, color='r', linestyle='--', alpha=0.3)
plt.title('Динамика тональности отзывов по неделям')
plt.xlabel('Неделя года')
plt.ylabel('Средняя полярность (от -1 до +1)')
plt.grid(True, alpha=0.3)
plt.show()

from sklearn.decomposition import LatentDirichletAllocation
from sklearn.feature_extraction.text import CountVectorizer
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

# Пример корпуса документов
documents = [
"Python идеально подходит для анализа данных и машинного обучения",
"Методы обработки естественного языка помогают понимать текстовые данные",
"Фреймворки машинного обучения упрощают создание моделей",
"Библиотеки Python для визуализации данных очень удобны",
"Нейронные сети показывают высокую эффективность в задачах обработки языка",
"Анализ тональности позволяет оценить отношение пользователей"
]

# Векторизация текста
vectorizer = CountVectorizer(max_features=100, stop_words='english')
X = vectorizer.fit_transform(documents)

# Тематическое моделирование с помощью LDA
n_topics = 2
lda = LatentDirichletAllocation(n_components=n_topics, random_state=42)
lda.fit(X)

# Получаем топ-слова для каждой темы
feature_names = vectorizer.get_feature_names_out()
n_top_words = 5

def plot_top_words(model, feature_names, n_top_words, n_topics):
fig, axes = plt.subplots(1, n_topics, figsize=(15, 8), sharex=True)
axes = axes.flatten()

for topic_idx, topic in enumerate(model.components_):
top_features_ind = topic.argsort()[:-n_top_words – 1:-1]
top_features = [feature_names[i] for i in top_features_ind]
weights = topic[top_features_ind]

ax = axes[topic_idx]
ax.barh(top_features, weights)
ax.set_title(f'Тема {topic_idx+1}')
ax.invert_yaxis()
ax.tick_params(axis='both', which='major', labelsize=10)

plt.tight_layout()
plt.suptitle('Топ-слова по темам', fontsize=16)
plt.subplots_adjust(top=0.9)
plt.show()

plot_top_words(lda, feature_names, n_top_words, n_topics)

import spacy
from spacy import displacy

# Загрузка модели
nlp = spacy.load("ru_core_news_sm")

text = "Сергей Брин и Ларри Пейдж основали Google в Калифорнии в 1998 году."
doc = nlp(text)

# Визуализация именованных сущностей
# В Jupyter Notebook
displacy.render(doc, style="ent", jupyter=True)

# Сохранение в HTML файл
html = displacy.render(doc, style="ent", page=True)
with open("entities.html", "w", encoding="utf-8") as f:
f.write(html)