TF-IDF в Python: векторизация текста для эффективной аналитики

TF-IDF(t, d, D) = TF(t, d) × IDF(t, D)

# Создание виртуальной среды (рекомендуется)
python -m venv tf_idf_env
# Активация виртуальной среды
# – для Windows:
tf_idf_env\Scripts\activate
# – для macOS/Linux:
source tf_idf_env/bin/activate

# Установка необходимых библиотек
pip install scikit-learn numpy pandas matplotlib seaborn

import numpy as np
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer

# Проверка версии sklearn
import sklearn
print(f"scikit-learn version: {sklearn.__version__}")

!pip install scikit-learn numpy pandas matplotlib seaborn

# Установка библиотек для предобработки текста
pip install nltk spacy

from sklearn.feature_extraction.text import TfidfVectorizer

# Создание экземпляра векторайзера
vectorizer = TfidfVectorizer()

# Корпус документов для примера
corpus = [
"Это первый документ.",
"Это второй пример документа.",
"А это третий документ.",
"Это еще один пример."
]

# Обучение векторайзера и преобразование текстов
X = vectorizer.fit_transform(corpus)

import pandas as pd

# Получение списка всех токенов
feature_names = vectorizer.get_feature_names_out()

# Преобразование разреженной матрицы в плотную
dense_matrix = X.toarray()

# Создание DataFrame для лучшей визуализации
df_tfidf = pd.DataFrame(dense_matrix, columns=feature_names)
print(df_tfidf)

import numpy as np

# Для каждого документа находим слова с самыми высокими весами TF-IDF
for i, doc in enumerate(corpus):
# Получаем индексы слов, отсортированных по убыванию важности
feature_index = X[i, :].nonzero()[1]
tfidf_scores = zip(feature_index, [X[i, x] for x in feature_index])
# Сортируем слова по весу TF-IDF
sorted_words = sorted(tfidf_scores, key=lambda x: x[1], reverse=True)

print(f"Документ {i+1}: {doc}")
# Выводим топ-3 слова (или меньше, если слов меньше)
top_n = min(3, len(sorted_words))
for idx, score in sorted_words[:top_n]:
print(f" – {feature_names[idx]}: {score:.4f}")

import numpy as np
import pandas as pd
from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split
from sklearn.svm import LinearSVC
from sklearn.metrics import classification_report

# Загружаем данные из датасета 20 Newsgroups
categories = ['alt.atheism', 'comp.graphics', 'sci.med', 'soc.religion.christian']
twenty_train = fetch_20newsgroups(subset='train', categories=categories, shuffle=True, random_state=42)

# Разделяем данные на тренировочные и тестовые
X_train, X_test, y_train, y_test = train_test_split(twenty_train.data, twenty_train.target, test_size=0.3, random_state=42)

# Проверяем размеры наших данных
print(f"Тренировочных документов: {len(X_train)}")
print(f"Тестовых документов: {len(X_test)}")
print(f"Категории: {twenty_train.target_names}")

# Создаем и настраиваем векторайзер TF-IDF
tfidf_vectorizer = TfidfVectorizer(
min_df=5, # Игнорируем термы, встречающиеся менее чем в 5 документах
max_df=0.8, # Игнорируем термы, встречающиеся более чем в 80% документов
sublinear_tf=True, # Применяем логарифмическое масштабирование (1 + log(tf))
use_idf=True, # Используем IDF
ngram_range=(1, 2), # Учитываем униграммы и биграммы
stop_words='english' # Убираем английские стоп-слова
)

# Обучаем векторайзер на тренировочных данных и трансформируем их
X_train_tfidf = tfidf_vectorizer.fit_transform(X_train)
X_test_tfidf = tfidf_vectorizer.transform(X_test)

# Проверяем размеры полученных матриц
print(f"Размер тренировочной TF-IDF матрицы: {X_train_tfidf.shape}")
print(f"Размер тестовой TF-IDF матрицы: {X_test_tfidf.shape}")

# Создаем и обучаем классификатор
classifier = LinearSVC(random_state=42)
classifier.fit(X_train_tfidf, y_train)

# Делаем предсказания
y_pred = classifier.predict(X_test_tfidf)

# Оцениваем результаты
print(classification_report(y_test, y_pred, target_names=twenty_train.target_names))

# Функция для получения наиболее важных слов для каждой категории
def get_top_features(vectorizer, clf, class_labels, n=20):
feature_names = vectorizer.get_feature_names_out()

# Для каждого класса выводим топ-n важных слов
top_features = {}
for i, class_label in enumerate(class_labels):
# Получаем веса слов для текущего класса
top_indices = np.argsort(clf.coef_[i])[-n:]
top_features[class_label] = [(feature_names[j], clf.coef_[i][j]) 
for j in top_indices]

return top_features

# Получаем топ-10 важных слов для каждой категории
top_features = get_top_features(tfidf_vectorizer, classifier, twenty_train.target_names, n=10)

# Выводим результаты
for category, features in top_features.items():
print(f"\nТоп-10 слов для категории '{category}':")
for feature, weight in reversed(features):
print(f" {feature}: {weight:.4f}")

import matplotlib.pyplot as plt
import seaborn as sns

# Создаем DataFrame для визуализации
viz_data = []
for category, features in top_features.items():
for term, weight in reversed(features):
viz_data.append({
'Category': category,
'Term': term,
'Weight': weight
})

viz_df = pd.DataFrame(viz_data)

# Визуализация
plt.figure(figsize=(12, 10))
g = sns.barplot(x='Weight', y='Term', hue='Category', data=viz_df)
plt.title('Top TF-IDF Terms by Category')
plt.tight_layout()
plt.show()

# Находим индексы неправильно классифицированных документов
misclassified_indices = np.where(y_test != y_pred)[0]

# Выводим несколько примеров ошибок
for idx in misclassified_indices[:5]: # Выводим первые 5 ошибок
doc = X_test[idx]
true_label = twenty_train.target_names[y_test[idx]]
pred_label = twenty_train.target_names[y_pred[idx]]

print(f"\nНеправильно классифицированный документ #{idx}")
print(f"Истинная категория: {true_label}")
print(f"Предсказанная категория: {pred_label}")

# Выводим фрагмент документа для анализа
print("\nФрагмент документа:")
print(" ".join(doc.split()[:50]), "...") # Первые 50 слов

import joblib

# Сохраняем обученную модель и векторайзер
joblib.dump(classifier, 'tfidf_classifier.pkl')
joblib.dump(tfidf_vectorizer, 'tfidf_vectorizer.pkl')

print("Модель и векторайзер успешно сохранены!")

# Пример загрузки и использования модели
loaded_vectorizer = joblib.load('tfidf_vectorizer.pkl')
loaded_classifier = joblib.load('tfidf_classifier.pkl')

# Тестирование на новых данных
new_docs = [
"I need help with my computer graphics card",
"What is the best treatment for flu?"
]

# Преобразуем новые документы в TF-IDF векторы
new_docs_tfidf = loaded_vectorizer.transform(new_docs)

# Делаем предсказания
predictions = loaded_classifier.predict(new_docs_tfidf)

# Выводим результаты
for doc, pred in zip(new_docs, predictions):
print(f"Документ: {doc}")
print(f"Предсказанная категория: {twenty_train.target_names[pred]}\n")

from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
import pandas as pd

# Загрузим небольшой набор документов для демонстрации
documents = [
"Машинное обучение – это подраздел искусственного интеллекта",
"Нейронные сети используются для решения задач машинного обучения",
"Python – популярный язык программирования для анализа данных",
"TensorFlow и PyTorch – библиотеки для глубокого обучения",
"Обработка естественного языка помогает компьютерам понимать тексты",
"Классификация текста – одна из задач обработки естественного языка",
"Регрессия – это метод прогнозирования числовых значений",
"Кластеризация группирует похожие объекты вместе"
]

# Создаем TF-IDF векторы
vectorizer = TfidfVectorizer(stop_words='english')
tfidf_matrix = vectorizer.fit_transform(documents)

# Вычисляем косинусное сходство между всеми документами
cosine_similarities = cosine_similarity(tfidf_matrix, tfidf_matrix)

# Создаем DataFrame для удобного отображения сходства
similarity_df = pd.DataFrame(cosine_similarities)
similarity_df.index = [f"Док {i+1}" for i in range(len(documents))]
similarity_df.columns = [f"Док {i+1}" for i in range(len(documents))]

def find_similar_documents(doc_index, cosine_sim, n=3):
# Получаем индексы похожих документов, отсортированных по сходству
similar_indices = np.argsort(cosine_sim[doc_index])[::-1]

# Исключаем сам документ
similar_indices = similar_indices[similar_indices != doc_index]

# Выбираем топ-n похожих документов
return similar_indices[:n]

# Пример использования: найдем 2 документа, наиболее похожих на документ #1
doc_index = 0
similar_indices = find_similar_documents(doc_index, cosine_similarities, n=2)

print(f"Документ #{doc_index+1}: {documents[doc_index]}")
print("\nПохожие документы:")
for i, idx in enumerate(similar_indices):
print(f"{i+1}. Документ #{idx+1} (сходство: {cosine_similarities[doc_index][idx]:.4f})")
print(f" {documents[idx]}")

from sklearn.cluster import KMeans

# Определяем оптимальное количество кластеров с помощью метода "локтя"
inertias = []
max_clusters = 8

for k in range(1, min(max_clusters+1, len(documents)+1)):
kmeans = KMeans(n_clusters=k, random_state=42)
kmeans.fit(tfidf_matrix)
inertias.append(kmeans.inertia_)

# В реальном проекте здесь был бы код для построения графика метода "локтя"
# для определения оптимального числа кластеров

# Используем K-means для кластеризации документов
num_clusters = 3 # Допустим, мы выбрали 3 кластера
kmeans = KMeans(n_clusters=num_clusters, random_state=42)
clusters = kmeans.fit_predict(tfidf_matrix)

# Выводим документы по кластерам
for cluster_id in range(num_clusters):
print(f"\nКластер {cluster_id+1}:")
for doc_idx, cluster in enumerate(clusters):
if cluster == cluster_id:
print(f" – {documents[doc_idx]}")

def get_cluster_keywords(vectorizer, kmeans, documents, clusters, top_n=5):
# Получаем TF-IDF матрицу
tfidf_matrix = vectorizer.transform(documents)

# Определяем ключевые слова для каждого кластера
cluster_keywords = {}
feature_names = vectorizer.get_feature_names_out()

for cluster_id in range(kmeans.n_clusters):
# Индексы документов, принадлежащих текущему кластеру
doc_indices = [i for i, c in enumerate(clusters) if c == cluster_id]

if not doc_indices: # Пропускаем пустые кластеры
continue

# Средние TF-IDF значения по всем документам кластера
cluster_tfidf = np.zeros_like(tfidf_matrix[0].toarray()[0])
for idx in doc_indices:
cluster_tfidf += tfidf_matrix[idx].toarray()[0]

cluster_tfidf /= len(doc_indices)

# Находим топ-N слов с наивысшими TF-IDF значениями
top_indices = cluster_tfidf.argsort()[::-1][:top_n]
top_terms = [(feature_names[i], cluster_tfidf[i]) for i in top_indices]

cluster_keywords[cluster_id] = top_terms

return cluster_keywords

# Получаем ключевые слова для каждого кластера
cluster_keywords = get_cluster_keywords(vectorizer, kmeans, documents, clusters, top_n=5)

# Выводим ключевые слова по кластерам
for cluster_id, keywords in cluster_keywords.items():
print(f"\nКлючевые слова для кластера {cluster_id+1}:")
for term, score in keywords:
print(f" – {term}: {score:.4f}")

def search_documents(query, documents, vectorizer=None):
if vectorizer is None:
# Если векторайзер не передан, создаем новый
vectorizer = TfidfVectorizer(stop_words='english')
doc_vectors = vectorizer.fit_transform(documents)
else:
# Используем предоставленный векторайзер
doc_vectors = vectorizer.transform(documents)

# Преобразуем запрос в TF-IDF вектор
query_vector = vectorizer.transform([query])

# Вычисляем косинусное сходство между запросом и всеми документами
similarities = cosine_similarity(query_vector, doc_vectors).flatten()

# Сортируем документы по убыванию релевантности
sorted_indices = similarities.argsort()[::-1]

results = []
for idx in sorted_indices:
if similarities[idx] > 0: # Выводим только релевантные документы
results.append({
'document': documents[idx],
'relevance': similarities[idx],
'index': idx
})

return results

# Пример использования поиска
search_query = "Python для машинного обучения"
search_results = search_documents(search_query, documents, vectorizer)

print(f"Результаты поиска по запросу: '{search_query}'\n")
for i, result in enumerate(search_results[:3]): # Выводим топ-3 результата
print(f"{i+1}. Релевантность: {result['relevance']:.4f}")
print(f" Документ #{result['index']+1}: {result['document']}")

from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
import matplotlib.cm as cm

# Уменьшаем размерность данных с помощью t-SNE
tsne = TSNE(n_components=2, random_state=42, perplexity=2)
reduced_data = tsne.fit_transform(tfidf_matrix.toarray())

# Создаем scatter plot с цветами, соответствующими кластерам
plt.figure(figsize=(10, 8))
colors = cm.rainbow(np.linspace(0, 1, num_clusters))

for i, (x, y) in enumerate(reduced_data):
plt.scatter(x, y, color=colors[clusters[i]], s=100)
plt.annotate(f"Док {i+1}", (x, y), fontsize=9, alpha=0.7)

plt.title('t-SNE визуализация документов, окрашенных по кластерам')
plt.xlabel('t-SNE 1')
plt.ylabel('t-SNE 2')
plt.tight_layout()

# В реальном коде здесь был бы вызов plt.show()

from sklearn.feature_extraction.text import CountVectorizer
import pandas as pd

# Пример текстов с эмоциональной окраской
sentiment_texts = [
"Это отличный продукт, я очень доволен покупкой!",
"Ужасное качество, полное разочарование.",
"Товар хороший, но доставка оставляет желать лучшего.",
"Превосходный сервис и быстрая доставка, рекомендую!",
"Не работает совершенно, выброшенные деньги."
]

sentiment_labels = ["позитивный", "негативный", "нейтральный", "позитивный", "негативный"]

# Создаем DataFrame для анализа
sentiment_df = pd.DataFrame({
'текст': sentiment_texts,
'эмоция': sentiment_labels
})

# Для каждой эмоции определяем ключевые слова с помощью TF-IDF
for sentiment in set(sentiment_labels):
# Выбираем тексты с текущей эмоцией
texts = sentiment_df[sentiment_df['эмоция'] == sentiment]['текст'].tolist()

if not texts:
continue

# Создаем TF-IDF векторайзер
sentiment_vectorizer = TfidfVectorizer(
min_df=1, max_df=0.9, stop_words=None, ngram_range=(1, 2)
)

# Получаем TF-IDF матрицу
sentiment_matrix = sentiment_vectorizer.fit_transform(texts)

# Вычисляем средние веса TF-IDF для всех слов
feature_names = sentiment_vectorizer.get_feature_names_out()
avg_weights = sentiment_matrix.mean(axis=0).A1

# Сортируем слова по весам и выбираем топ-5
top_indices = avg_weights.argsort()[::-1][:5]
top_terms = [(feature_names[i], avg_weights[i]) for i in top_indices]

print(f"\nКлючевые слова для '{sentiment}' текстов:")
for term, weight in top_terms:
if weight > 0: # Выводим только слова с ненулевыми весами
print(f" – {term}: {weight:.4f}")