Анализ и классификация текста на Python: техники обработки данных

import pandas as pd
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.model_selection import train_test_split

# Загрузка данных
data = pd.DataFrame({
'text': ['Отличный продукт, очень доволен', 'Ужасное качество, не рекомендую',
'Лучшая покупка в этом году', 'Полное разочарование, зря потратил деньги'],
'label': ['положительный', 'отрицательный', 'положительный', 'отрицательный']
})

# Разделение на тренировочную и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(
data['text'], data['label'], test_size=0.25, random_state=42)

# Векторизация текста
vectorizer = CountVectorizer()
X_train_vec = vectorizer.fit_transform(X_train)
X_test_vec = vectorizer.transform(X_test)

# Обучение модели
clf = MultinomialNB()
clf.fit(X_train_vec, y_train)

# Предсказание
new_review = ['Хороший товар, буду заказывать ещё']
new_review_vec = vectorizer.transform(new_review)
prediction = clf.predict(new_review_vec)
print(f"Предсказанный класс: {prediction[0]}")

import re
import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from nltk.stem import WordNetLemmatizer

# Загрузка необходимых ресурсов
nltk.download('punkt')
nltk.download('stopwords')
nltk.download('wordnet')

def preprocess_text(text):
# Удаление HTML-тегов
text = re.sub(r'<.*?>', '', text)

# Приведение к нижнему регистру
text = text.lower()

# Удаление чисел и пунктуации
text = re.sub(r'[^\w\s]', '', text)
text = re.sub(r'\d+', '', text)

# Токенизация
tokens = word_tokenize(text)

# Удаление стоп-слов
stop_words = set(stopwords.words('russian'))
filtered_tokens = [word for word in tokens if word not in stop_words]

# Лемматизация
lemmatizer = WordNetLemmatizer()
lemmatized_tokens = [lemmatizer.lemmatize(word) for word in filtered_tokens]

# Соединение токенов обратно в текст
processed_text = ' '.join(lemmatized_tokens)

return processed_text

# Пример использования
raw_text = "HTML-текст с разными СИМВОЛАМИ, цифрами 12345 и лишними словами."
processed_text = preprocess_text(raw_text)
print(processed_text)

from sklearn.feature_extraction.text import TfidfVectorizer

# Создание векторизатора
tfidf_vectorizer = TfidfVectorizer(max_features=1000, 
stop_words='english')

# Примеры документов
documents = [
"Python is a great programming language for text analysis",
"Text classification requires preprocessing and feature extraction",
"Machine learning algorithms can classify text effectively"
]

# Преобразование текстов в TF-IDF векторы
tfidf_matrix = tfidf_vectorizer.fit_transform(documents)

# Получение имен признаков (слов)
feature_names = tfidf_vectorizer.get_feature_names_out()

# Вывод TF-IDF значений для первого документа
first_doc_vector = tfidf_matrix[0]
df = pd.DataFrame({'term': feature_names, 
'tfidf': first_doc_vector.toarray()[0]})
df = df.sort_values('tfidf', ascending=False).head(5)
print(df)

from transformers import BertTokenizer, BertModel
import torch

# Загрузка предобученной модели и токенизатора
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertModel.from_pretrained('bert-base-uncased')

# Текст для векторизации
text = "Python позволяет эффективно анализировать текстовые данные."

# Токенизация и получение входов для модели
inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True)

# Получение векторных представлений
with torch.no_grad():
outputs = model(**inputs)

# Использование [CLS] токена как представления всего предложения
sentence_embedding = outputs.last_hidden_state[:, 0, :]
print(f"Размерность векторного представления: {sentence_embedding.shape}")

from sklearn.naive_bayes import MultinomialNB
from sklearn.svm import LinearSVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.pipeline import Pipeline
from sklearn.model_selection import cross_val_score
import numpy as np

# Подготовка данных
texts = ["Отличный продукт, рекомендую", "Ужасное качество, не покупайте", 
"Превосходит ожидания, очень доволен", "Полное разочарование, выброшенные деньги",
"Хорошее соотношение цены и качества", "Не соответствует описанию, верну"]
labels = [1, 0, 1, 0, 1, 0] # 1 – положительный, 0 – отрицательный

# Создание и оценка различных моделей
classifiers = [
("Naive Bayes", MultinomialNB()),
("SVM", LinearSVC()),
("Random Forest", RandomForestClassifier()),
("Logistic Regression", LogisticRegression(max_iter=1000))
]

for name, classifier in classifiers:
# Создание пайплайна: векторизация + классификатор
pipeline = Pipeline([
('tfidf', TfidfVectorizer()),
('clf', classifier)
])

# Оценка с помощью кросс-валидации
scores = cross_val_score(pipeline, texts, labels, cv=3)
print(f"{name}: Средняя точность = {np.mean(scores):.4f}, Стандартное отклонение = {np.std(scores):.4f}")

import tensorflow as tf
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense, Dropout

# Пример данных
texts = [
"Этот продукт превзошел все мои ожидания",
"Разочарован качеством, не рекомендую",
"Отличное соотношение цены и качества",
"Совершенно бесполезная вещь, зря потратил деньги",
"Доволен покупкой, буду заказывать еще"
]
labels = [1, 0, 1, 0, 1] # 1 – положительный, 0 – отрицательный

# Токенизация текста
max_words = 1000 # Максимальное количество слов в словаре
max_len = 20 # Максимальная длина последовательности

tokenizer = Tokenizer(num_words=max_words)
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
word_index = tokenizer.word_index
print(f'Найдено уникальных слов: {len(word_index)}')

# Padding последовательностей
data = pad_sequences(sequences, maxlen=max_len)

# Создание модели
model = Sequential()
model.add(Embedding(max_words, 128, input_length=max_len))
model.add(LSTM(64, dropout=0.2, recurrent_dropout=0.2))
model.add(Dense(32, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))

# Компиляция модели
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
print(model.summary())

# Обучение модели (в реальных задачах нужно больше данных)
model.fit(data, labels, epochs=10, batch_size=2, validation_split=0.2)

# Предсказание для нового текста
new_text = ["Хороший товар, соответствует описанию"]
new_seq = tokenizer.texts_to_sequences(new_text)
new_padded = pad_sequences(new_seq, maxlen=max_len)
prediction = model.predict(new_padded)
print(f"Предсказанная вероятность положительного класса: {prediction[0][0]:.4f}")

from transformers import AutoModelForSequenceClassification, AutoTokenizer
import torch

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

# Пример текста для анализа
text = "Отличный сервис, всем рекомендую!"

# Токенизация
inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True)

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

# Интерпретация результатов
label_names = ["Негативный", "Нейтральный", "Позитивный"]
for i, pred in enumerate(predictions[0]):
print(f"{label_names[i]}: {pred.item():.4f}")

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report

# Загрузка данных (пример)
df = pd.DataFrame({
'review': [
'Отличный продукт, очень доволен покупкой',
'Товар хороший, но доставка подвела',
'Ужасное качество, не рекомендую',
'Нормальный продукт, соответствует цене',
'Восхитительно, превзошло все ожидания',
'Разочарован, не буду больше покупать',
'Обычный товар, ничего особенного',
'Приемлемое качество за эти деньги'
],
'sentiment': ['positive', 'neutral', 'negative', 'neutral', 
'positive', 'negative', 'neutral', 'neutral']
})

# Разделение данных
X_train, X_test, y_train, y_test = train_test_split(
df['review'], df['sentiment'], test_size=0.25, random_state=42)

# Векторизация с использованием TF-IDF
vectorizer = TfidfVectorizer(ngram_range=(1, 2)) # используем униграммы и биграммы
X_train_vect = vectorizer.fit_transform(X_train)
X_test_vect = vectorizer.transform(X_test)

# Обучение модели градиентного бустинга
model = GradientBoostingClassifier(n_estimators=100, random_state=42)
model.fit(X_train_vect, y_train)

# Оценка модели
y_pred = model.predict(X_test_vect)
print(classification_report(y_test, y_pred))

# Пример анализа новых отзывов
new_reviews = [
'Качественный товар, буду заказывать еще',
'Не понравилось, много дефектов'
]
new_reviews_vect = vectorizer.transform(new_reviews)
predictions = model.predict(new_reviews_vect)

for review, sentiment in zip(new_reviews, predictions):
print(f'Текст: "{review}"\nТональность: {sentiment}\n')

import pandas as pd
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.multiclass import OneVsRestClassifier
from sklearn.svm import LinearSVC
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, f1_score

# Пример набора данных новостей
df = pd.DataFrame({
'text': [
'Новый закон о налогах вступит в силу с января следующего года',
'Сборная России по футболу проиграла в матче с Бразилией',
'Ученые обнаружили новый вид рыб в Тихом океане',
'Президент подписал указ о социальных выплатах',
'Завершился чемпионат мира по хоккею',
'Экспедиция в Антарктиду обнаружила следы древних микроорганизмов'
],
'category': ['политика', 'спорт', 'наука', 'политика', 'спорт', 'наука']
})

# Разделение данных
X_train, X_test, y_train, y_test = train_test_split(
df['text'], df['category'], test_size=0.2, random_state=42)

# Векторизация
vectorizer = TfidfVectorizer(max_features=1000, min_df=2)
X_train_tfidf = vectorizer.fit_transform(X_train)
X_test_tfidf = vectorizer.transform(X_test)

# Создание и обучение модели
clf = OneVsRestClassifier(LinearSVC(random_state=42))
clf.fit(X_train_tfidf, y_train)

# Оценка модели
y_pred = clf.predict(X_test_tfidf)
print(f'Точность: {accuracy_score(y_test, y_pred):.2f}')
print(f'F1-мера: {f1_score(y_test, y_pred, average="weighted"):.2f}')

# Классификация новой статьи
new_article = ['В Госдуме обсудили проект бюджета на следующий год']
new_article_tfidf = vectorizer.transform(new_article)
predicted_category = clf.predict(new_article_tfidf)
print(f'Предсказанная категория для статьи: {predicted_category[0]}')

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns

# Пример набора данных электронных писем
df = pd.DataFrame({
'email': [
'Поздравляем! Вы выиграли миллион долларов, перейдите по ссылке',
'Уважаемый клиент, ваша учетная запись была заблокирована',
'Привет, как насчет ужина в пятницу?',
'Уведомление: ваш заказ №12345 отправлен',
'Получите бесплатный кредит прямо сейчас! Только сегодня!',
'Напоминание о встрече завтра в 15:00',
'Увеличьте размер своего капитала на 300% за неделю!',
'Документы к сегодняшнему совещанию во вложении'
],
'is_spam': [1, 1, 0, 0, 1, 0, 1, 0] # 1 – спам, 0 – не спам
})

# Разделение данных
X_train, X_test, y_train, y_test = train_test_split(
df['email'], df['is_spam'], test_size=0.25, random_state=42)

# Векторизация с использованием Bag of Words
vectorizer = CountVectorizer(stop_words='english')
X_train_counts = vectorizer.fit_transform(X_train)
X_test_counts = vectorizer.transform(X_test)

# Обучение Наивного Байеса
model = MultinomialNB()
model.fit(X_train_counts, y_train)

# Оценка модели
y_pred = model.predict(X_test_counts)
print(f'Точность: {accuracy_score(y_test, y_pred):.2f}')
print(f'Точность (Precision): {precision_score(y_test, y_pred):.2f}')
print(f'Полнота (Recall): {recall_score(y_test, y_pred):.2f}')
print(f'F1-мера: {f1_score(y_test, y_pred):.2f}')

# Визуализация матрицы ошибок
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
xticklabels=['Не спам', 'Спам'], yticklabels=['Не спам', 'Спам'])
plt.xlabel('Предсказанные значения')
plt.ylabel('Истинные значения')
plt.title('Матрица ошибок')
plt.show()

# Классификация новых писем
new_emails = [
'Срочно! Ваша кредитная карта заблокирована',
'Пожалуйста, проверьте отчет, который я отправил утром'
]
new_emails_counts = vectorizer.transform(new_emails)
predictions = model.predict(new_emails_counts)
probas = model.predict_proba(new_emails_counts)

for email, pred, proba in zip(new_emails, predictions, probas):
spam_probability = proba[1] # Вероятность класса "спам"
print(f'Письмо: "{email}"\nКлассификация: {"Спам" if pred == 1 else "Не спам"}')
print(f'Вероятность спама: {spam_probability:.2f}\n')

from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
import torch
import numpy as np
from datasets import Dataset
import evaluate

# Загрузка предобученной многоязычной модели
model_name = "xlm-roberta-base"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

# Пример многоязычного набора данных для классификации тональности
texts = [
"This product is amazing, I love it!", # английский
"Ce produit est terrible, je ne le recommande pas.", # французский
"Dieses Produkt ist wunderbar, ich bin sehr zufrieden.", # немецкий
"Questo prodotto è pessimo, non lo consiglierei.", # итальянский
"Este producto es fantástico, muy recomendable.", # испанский
"Этот продукт превосходен, очень рекомендую." # русский
]
labels = [1, 0, 1, 0, 1, 1] # 1 – положительный, 0 – отрицательный

# Токенизация данных
def tokenize_function(examples):
return tokenizer(examples["text"], padding="max_length", truncation=True)

# Создание датасета
train_dataset = Dataset.from_dict({"text": texts, "label": labels})
tokenized_datasets = train_dataset.map(tokenize_function, batched=True)

# Настройка обучения
training_args = TrainingArguments(
output_dir="./results",
num_train_epochs=3,
per_device_train_batch_size=4,
per_device_eval_batch_size=4,
warmup_steps=500,
weight_decay=0.01,
logging_dir="./logs",
)

# Создание тренера
trainer = Trainer(
model=model,
args=training_args,
train_dataset=tokenized_datasets,
)

# Обучение модели
trainer.train()

# Функция для предсказания
def predict_sentiment(text):
inputs = tokenizer(text, padding=True, truncation=True, return_tensors="pt")
outputs = model(**inputs)
probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
sentiment = "положительный" if probabilities[0][1] > 0.5 else "отрицательный"
confidence = probabilities[0][1].item() if sentiment == "положительный" else probabilities[0][0].item()
return sentiment, confidence

# Тестирование на новых многоязычных примерах
new_texts = [
"I really dislike this service.", # английский
"Wirklich gutes Preis-Leistungs-Verhältnis.", # немецкий
"Ужасное качество, больше не буду покупать." # русский
]

for text in new_texts:
sentiment, confidence = predict_sentiment(text)
print(f"Текст: '{text}'")
print(f"Тональность: {sentiment}")
print(f"Уверенность: {confidence:.2f}\n")