PYTHON АНАЛИЗ ТЕКСТА

Было → стало

Сравните сами две картинки: это слова из первого том без обработки и после анализа и добавления фильтров. В первой картинке всё внимание съели основные глаголы действия и «свой», а на второй видна суть книги.

Примеры практических задач SpaCy

Анализ тональности текста

Анализ тональности текста является важным компонентом анализа настроений и мнений в текстовых данных. SpaCy, хотя и не является специализированной библиотекой для анализа тональности, может быть полезным инструментом для предварительной обработки и анализа текстов перед применением специализированных методов.

   import spacy
from textblob import TextBlob

nlp = spacy.load("en_core_web_sm")

text = "I love this product. It's amazing!"

doc = nlp(text)

# Используем TextBlob для анализа тональности
analysis = TextBlob(text)

# Оцениваем настроение текста
sentiment = analysis.sentiment.polarity

if sentiment > 0:
    sentiment_label = "positive"
elif sentiment < 0:
    sentiment_label = "negative"
else:
    sentiment_label = "neutral"

print(f"Sentiment: {sentiment_label}")
  
  

Извлечение ключевых слов

Извлечение ключевых слов из текста помогает сжать информацию и выделить самые важные аспекты содержания. SpaCy предоставляет возможность извлекать ключевые слова, используя частоту слов или их семантическое значение.

   import spacy

nlp = spacy.load("en_core_web_sm")

text = "Natural language processing is a field of study focused on making sense of text data."

doc = nlp(text)

# Извлекаем ключевые слова на основе частоты
keywords_freq = [token.text for token in doc if not token.is_stop and token.is_alpha]

# Извлекаем ключевые слова на основе веса встроенных векторов
keywords_semantic = [token.text for token in doc if not token.is_stop and token.vector_norm > 0]

print("Keywords based on frequency:", keywords_freq)
print("Keywords based on semantics:", keywords_semantic)
  
  

Автоматическая аннотация текстов

Автоматическая аннотация текстов позволяет автоматически добавлять дополнительные метаданные к текстам. Это может быть полезно, например, при создании информационных ресурсов, где необходимо предоставить пользователям дополнительные сведения о тексте.

   import spacy

nlp = spacy.load("en_core_web_sm")

text = "John is a data scientist working in a tech company."

doc = nlp(text)

# Добавляем аннотацию с информацией о профессии и компании
doc.ents = [(doc[3:5], "PERSON"), (doc[8:11], "ORG")]

# Выводим аннотированный текст
for ent in doc.ents:
    print(ent.text, "-", ent.label_)
  
  

SpaCy позволяет не только анализировать тексты, но и добавлять к ним дополнительные метаданные для обогащения контента. Это может быть полезно при создании разнообразных приложений, таких как информационные порталы, поисковые системы и многие другие.

Лемматизация

В отличие от стемминга, лемматизация сводит слова к их лемме — это более сложный процесс, который учитывает морфологический анализ слов. Лемматизация более точно обрабатывает слова, приводя их к словарной форме.

1. • Лемматизация на английском языке:

     Нужно загрузить данные omw-1.4 с помощью NLTK Downloader:

        import nltk
     nltk.download('omw-1.4')  
       

        from nltk.stem import WordNetLemmatizer
     from nltk.tokenize import word_tokenize
     
     lemmatizer = WordNetLemmatizer()
     text = "The lemmatized form of leaves is leaf"
     tokens = word_tokenize(text)
     lemmatized_words = [lemmatizer.lemmatize(word) for word in tokens]
     print(lemmatized_words)  
       

   • Лемматизация на русском языке (используя стеммер, так как для русского языка NLTK не предоставляет прямой лемматизатор):

        stemmer = SnowballStemmer("russian")
     text = "Лемматизированная форма слова листья это лист"
     tokens = word_tokenize(text)
     lemmatized_words = [stemmer.stem(word) for word in tokens]
     print(lemmatized_words)
       
       

Лемматизация важна в задачах, где требуется высокая точность обработки текста, таких как машинный перевод, семантический анализ текста и создание систем вопросов-ответов, где важно точно понимать значение слов в контексте.

Анализ настроений

Анализ настроений, иногда называемый «определением тональности», включает использование NLP, статистических или машинно-обученных алгоритмов для изучения, идентификации и извлечения информации о настроениях из текстов. Он может быть столь же простым, как определение положительной или отрицательной окраски отзыва, или настолько сложным, как определение более тонких эмоциональных состояний, таких как ирония или разочарование.

Анализ настроений не без проблем. Одна из основных сложностей заключается в интерпретации сарказма, иронии и фигуративного языка. Например, фраза «Ну да, конечно, мне очень понравилось, когда мой телефон перестал работать» на самом деле выражает разочарование, хотя на первый взгляд может показаться положительной. Распознавание таких тонкостей требует продвинутых алгоритмов и, часто, контекстуального анализа.

Анализ настроений (или сентимент-анализ) в NLTK часто сводится к классификации текста на позитивный или негативный. Чтобы реализовать анализ настроений, можно использовать разные подходы.

Простая классификация с использованием предварительно обученных данных

   import nltk
from nltk.sentiment import SentimentIntensityAnalyzer

nltk.download('vader_lexicon')

sia = SentimentIntensityAnalyzer()
text = "NLTK is amazing for natural language processing!"
print(sia.polarity_scores(text))  
  

Классификация с использованием настраиваемых тренировочных данных

   import nltk
from nltk.classify import NaiveBayesClassifier
from nltk.corpus import subjectivity
from nltk.sentiment import SentimentAnalyzer
from nltk.sentiment.util import *

nltk.download('subjectivity')

n_instances = 100
subj_docs = [(sent, 'subj') for sent in subjectivity.sents(categories='subj')[:n_instances]]
obj_docs = [(sent, 'obj') for sent in subjectivity.sents(categories='obj')[:n_instances]]
train_subj_docs = subj_docs[:80]
test_subj_docs = subj_docs[80:100]
train_obj_docs = obj_docs[:80]
test_obj_docs = obj_docs[80:100]
training_docs = train_subj_docs+train_obj_docs
testing_docs = test_subj_docs+test_obj_docs

sentim_analyzer = SentimentAnalyzer()
all_words_neg = neg_tagged_word_feats(sentim_analyzer.all_words(training_docs), mark_negation=True)
unigram_feats = sentim_analyzer.unigram_word_feats(all_words_neg, min_freq=4)
sentim_analyzer.add_feat_extractor(extract_unigram_feats, unigrams=unigram_feats)
training_set = sentim_analyzer.apply_features(training_docs)
test_set = sentim_analyzer.apply_features(testing_docs)

trainer = NaiveBayesClassifier.train
classifier = sentim_analyzer.train(trainer, training_set)

for key,value in sorted(sentim_analyzer.evaluate(test_set).items()):
    print('{0}: {1}'.format(key, value))  
  

Использование TextBlob для анализа настроений

   from textblob import TextBlob
import nltk

nltk.download('movie_reviews')
nltk.download('punkt')

text = "I love NLTK. It's incredibly helpful!"
blob = TextBlob(text)
print(blob.sentiment)  
  

Анализ настроений с использованием токенизатора и списка стоп-слов

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

nltk.download('stopwords')
nltk.download('vader_lexicon')

stop_words = set(stopwords.words('english'))
text = "NLTK is not bad for learning NLP."
filtered_text = ' '.join([word for word in word_tokenize(text) if not word in stop_words])

sia = SentimentIntensityAnalyzer()
print(sia.polarity_scores(filtered_text))  
  

Комбинирование лемматизации и анализа настроений

   from nltk.stem import WordNetLemmatizer
from nltk.tokenize import word_tokenize
from nltk.sentiment import SentimentIntensityAnalyzer
import nltk

nltk.download('wordnet')
nltk.download('vader_lexicon')

lemmatizer = WordNetLemmatizer()
text = "The movie was not good. The plot was terrible!"
lemmatized_text = ' '.join([lemmatizer.lemmatize(word) for word in word_tokenize(text)])

sia = SentimentIntensityAnalyzer()
print(sia.polarity_scores(lemmatized_text))  
  

Важно отметить, что для корректной работы некоторых примеров может потребоваться установка дополнительных библиотек, таких как textblob
.

Модель «Мешок слов» (Bag of Words, BoW) является основным методом представления текстовых данных в обработке естественного языка (Natural Language Processing, NLP). Она преобразует текст в числовой вектор, где каждое слово в тексте представляется количеством его появлений.

Модель BoW

В модели BoW текст (например, предложение или документ) представляется в виде «мешка» его слов, не учитывая грамматику и порядок слов, но сохраняя мультиплицивность. Это преобразование текста в набор чисел позволяет использовать стандартные методы машинного обучения, которые работают на числовых данных.

В анализе настроений модель BoW используется для преобразования текстовых данных в формат, пригодный для алгоритмов машинного обучения. Так, текстовые данные (например, отзывы пользователей) преобразуются в числовые векторы, на которых можно обучать классификаторы для определения, например, позитивного или негативного отношения.

Создание BoW с NLTK и использование его для классификации

   import nltk
from nltk.tokenize import word_tokenize
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

nltk.download('punkt')

# Пример данных
texts = ["I love this product", "This is a bad product", "I dislike this", "This is the best!"]
labels = [1, 0, 0, 1]  # 1 - позитивный, 0 - негативный

# Токенизация
tokens = [word_tokenize(text) for text in texts]

# Создание BoW модели
vectorizer = CountVectorizer()
bow = vectorizer.fit_transform([' '.join(token) for token in tokens])

# Разделение данных на обучающую и тестовую выборку
X_train, X_test, y_train, y_test = train_test_split(bow, labels, test_size=0.3)

# Обучение классификатора
classifier = MultinomialNB()
classifier.fit(X_train, y_train)

# Оценка классификатора
predictions = classifier.predict(X_test)
print("Accuracy:", accuracy_score(y_test, predictions))
  
  

Пример 2: Простой анализ настроений с BoW и NLTK

   import nltk
from nltk.corpus import movie_reviews
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import accuracy_score

nltk.download('movie_reviews')

# Загрузка данных
documents = [(list(movie_reviews.words(fileid)), category)
             for category in movie_reviews.categories()
             for fileid in movie_reviews.fileids(category)]
random.shuffle(documents)

# Подготовка данных
texts = [' '.join(doc) for doc, _ in documents]
labels = [1 if category == 'pos' else 0 for _, category in documents]

# Создание BoW модели
vectorizer = CountVectorizer()
bow = vectorizer.fit_transform(texts)

# Разделение данных на обучающую и тестовую выборку
X_train, X_test, y_train, y_test = train_test_split(bow, labels, test_size=0.3)

# Обучение классификатора
classifier = MultinomialNB()
classifier.fit(X_train, y_train)

# Оценка классификатора
predictions = classifier.predict(X_test)
print("Accuracy:", accuracy_score(y_test, predictions))
  
  

BoW служит мостом между текстовыми данными и числовыми методами.

NLTK с его легкостью использования делают его идеальным выбором для широкого спектра задач обработки текстовых данных.

Более подробно с NLTK можно ознакомиться здесь
.

А практические навыки по аналитике вы можете получить от экспертов отрасли в рамках онлайн-курсов от моих коллег из OTUS. Подробнее в каталоге.

Работа с векторными представлениями

Встроенные векторы слов

Понятие векторного представления слов

Векторные представления слов — это числовые векторы, представляющие слова в многомерном пространстве таким образом, что семантически близкие слова имеют близкие векторы. Это понятие основано на гипотезе о дистрибутивности, согласно которой слова, используемые в похожих контекстах, имеют схожие значения.

Использование встроенных векторов слов в spaCy

Одной из мощных особенностей spaCy является наличие встроенных векторов слов, которые могут быть использованы для анализа семантической близости и сходства между словами. Эти векторы обучены на больших объемах текста и позволяют сравнивать слова на основе их семантического значения.

   import spacy

nlp = spacy.load("en_core_web_sm")

# Получаем векторное представление слова "cat"
vector_cat = nlp("cat").vector

# Получаем векторное представление слова "dog"
vector_dog = nlp("dog").vector

# Вычисляем косинусное расстояние между векторами
similarity = vector_cat.dot(vector_dog) / (vector_cat.norm() * vector_dog.norm())

print("Similarity between 'cat' and 'dog':", similarity)
  
  

Пользовательские векторы

Обучение собственных векторных представлений на корпусе текстов

В некоторых случаях может потребоваться обучить собственные векторные представления слов на специфическом корпусе текстов. Это особенно полезно, если вы работаете с узкоспециализированной терминологией или имеете доступ к большому объему текстов данных.

   import spacy
from gensim.models import Word2Vec

# Загружаем языковую модель
nlp = spacy.load("en_core_web_sm")

# Подготавливаем текстовый корпус
corpus = ["I like cats.", "Dogs are friendly.", "Cats and dogs are pets."]

# Токенизируем и лемматизируем текст
processed_corpus = []
for doc in nlp.pipe(corpus):
    processed_corpus.append([token.lemma_ for token in doc])

# Обучаем модель Word2Vec
model = Word2Vec(processed_corpus, vector_size=100, window=5, min_count=1, sg=0)

# Сохраняем модель
model.save("custom_word_vectors.model")
  
  

Применение пользовательских векторов в задачах классификации и кластеризации

Пользовательские векторные представления слов могут быть использованы в различных задачах машинного обучения, таких как классификация и кластеризация. Например, вы можете использовать эти векторы для обучения модели классификации тональности текста или для кластеризации похожих документов.

   from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

# Загружаем модель Word2Vec
custom_model = Word2Vec.load("custom_word_vectors.model")

# Получаем векторное представление слова "cat"
vector_cat = custom_model.wv["cat"]

# Получаем векторное представление слова "dog"
vector_dog = custom_model.wv["dog"]

# Подготавливаем данные для классификации
X = [vector_cat, vector_dog]
y = ["animal", "animal"]

# Обучаем модель классификации
classifier = SVC()
classifier.fit(X, y)

# Тестируем модель
test_vector = custom_model.wv["dog"]
predicted_label = classifier.predict([test_vector])[0]

print("Predicted label for 'dog':", predicted_label)  
  

Векторные представления слов открывают двери к множеству интересных задач. Они позволяют не только анализировать близость слов, но и использовать эту информацию для решения более сложных задач, таких как классификация и кластеризация. Ваша способность создавать и использовать собственные векторы дает вам бескрайний потенциал в области анализа текста.

Зачем это всё?

То, что мы сделаем, — типичная задача аналитика, которому нужно убрать шелуху и оставить только самое важное. Если вы хотели попробовать себя в роли аналитика, но не знали, с чего начать, — попробуйте с этого.

Что делаем сегодня

Сегодня мы поиграем с данными и извлечём ещё кое-какие знания из текстов Толстого:

• разделим существительные, прилагательные и глаголы;
• каждую такую группу слов сохраним в отдельном списке и построим для каждой своё облако тегов;
• оптимизируем код так, чтобы всё это можно было сделать за один проход.

Смысл в том, что существительные нам покажут ключевые элементы, вокруг которых вращается сюжет, прилагательные покажут эмоциональную окраску и характеристики героев, а глаголы — основное действие, которое происходит в книге.

Техники предварительной обработки текста в NLP с использованием NLTK

Токенизация

Токенизация — это процесс разбиения текста на более мелкие части, такие как слова или предложения. Это первый шаг в анализе текста, который позволяет преобразовать непрерывный текст в дискретные элементы, с которыми можно работать отдельно. Этот процесс помогает в выявлении ключевых слов и фраз, а также в упрощении последующего анализа текста.

1. В NLTK можно применять так:

   • Разбиение на слова:

        import nltk
     nltk.download('punkt')  
       

     Этот код загрузит необходимые данные punkt
     , которые используются для токенизации текста.

        from nltk.tokenize import word_tokenize
     
     text = "NLTK упрощает обработку текста."
     word_tokens = word_tokenize(text)
     print(word_tokens)  
       

   • Разбиение на предложения:

        from nltk.tokenize import sent_tokenize
     
     text = "OTUS. Наш сайт https://otus.ru/."
     sentence_tokens = sent_tokenize(text)
     print(sentence_tokens)  
       

Токенизация полезна в задачах, где необходимо анализировать отдельные слова или фразы, например, при определении ключевых слов в тексте, анализе частотности слов или при обучении моделей машинного обучения для классификации текста.

Удаление стоп-слов

Стоп-слова — это общеупотребительные слова в языке, которые обычно несут мало смысловой нагрузки (например, «и», «в», «на»). Их удаление позволяет сократить объем данных для анализа и сосредоточиться на более значимых словах, что повышает точность и эффективность обработки текста.

1. • Фильтрация стоп-слов на русском языке:

     Нужно загрузить данные stopwords
     с помощью NLTK Downloader. Это делается так:

        import nltk
     nltk.download('stopwords')  
       

        from nltk.corpus import stopwords
     from nltk.tokenize import word_tokenize
     
     text = "NLTK помогает в удалении стоп-слов из текста."
     tokens = word_tokenize(text)
     stop_words = set(stopwords.words('russian'))
     filtered_tokens = [word for word in tokens if word not in stop_words]
     
     print(filtered_tokens)  
       

   • Фильтрация стоп-слов на английском языке:

        text = "NLTK helps in removing stopwords from the text."
     tokens = word_tokenize(text)
     filtered_tokens = [word for word in tokens if not word in stopwords.words('english')]
     print(filtered_tokens)
       
       

Удаление стоп-слов часто юзается в задачах обработки текста, таких как анализ настроений, классификация текстов, создание облаков слов и в информационном поиске, где важно выделить ключевую информацию из текста.

Стемминг

Стемминг — это процесс сведения слов к их основной (корневой) форме, удаляя окончания и суффиксы. Это помогает уменьшить сложность текста и улучшить производительность алгоритмов анализа.

1. • Стемминг на английском языке:

        from nltk.stem import PorterStemmer
     from nltk.tokenize import word_tokenize
     
     stemmer = PorterStemmer()
     text = "The stemmed form of leaves is leaf"
     tokens = word_tokenize(text)
     stemmed_words = [stemmer.stem(word) for word in tokens]
     print(stemmed_words)
       
       

   • Стемминг на русском языке:

        from nltk.stem.snowball import SnowballStemmer
     
     stemmer = SnowballStemmer("russian")
     text = "Листовые листочки лист листва листве почему так"
     tokens = word_tokenize(text)
     stemmed_words = [stemmer.stem(word) for word in tokens]
     print(stemmed_words)  
       

Стемминг наиболее полезен в задачах, где важно уменьшить разнообразие словоформ, например, при индексации текста для поисковых систем, в аналитике текстов большого объема и при обучении моделей машинного обучения для классификации или кластеризации текстов.

Подготовка данных

Первым делом нам нужно подготовить наши текстовые данные для анализа. Это может включать в себя:

• удаление пробелов, знаков препинания и чисел
• приведение текста к нижнему регистру
• удаление стоп-слов (например, «a», «an», «the»)
• лемматизация или стемминг (приведение слов к их основной форме)

Пример кода для подготовки данных:

  import nltk
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer

nltk.download('stopwords')
nltk.download('wordnet')

text = "This is a sample text for text analysis using Python."
text = text.lower()
words = nltk.word_tokenize(text)
words = [word for word in words if word.isalpha()]
stop_words = set(stopwords.words('english'))
words = [word for word in words if word not in stop_words]
lemmatizer = WordNetLemmatizer()
words = [lemmatizer.lemmatize(word) for word in words]
  

Что с этим можно сделать

Вот несколько идей:

1. Подразбить тома на главы и посмотреть на частотность на микроуровне.
2. Докрутить токенизатор, возвращая все слова в начальную форму, и проанализировать снова.
3. Докрутить токенизатор, чтобы он отдельно смотрел на существительные, отдельно — на прилагательные, отдельно — на глаголы. В идеале ещё отделить имена людей и имена собственные.
4. Заменить частотность на анализ связей: например, что чаще всего делал Пьер или Наташа? 
5. Насобирать своих старых текстов из соцсетей и проанализировать, как вы менялись с годами: какие слова использовали. Для этого сначала напарсить сайт, не привлекая внимания. 
6. Записать свою устную речь, расшифровать через облако и найти слова-паразиты.
7. То же самое, но с другими людьми.
8. Напарсить текстов какого-нибудь издания до того, как сменилась команда, и после.
9. Насобирать новостных сюжетов за год и построить карту популярных слов в течение года.
10. Ничего из этого не делать, а открыть API-платформу OpenAI и натренировать нейронку на всём корпусе текстов Толстого. 

Что-то из этого мы сделаем в будущем. Или это вы сделаете сами, потому что пойдёте заниматься дата-сайенсом впереди нас.

Приводим слова в нормальную форму

Все изменения будем делать в уже готовом скрипте, который мы собрали в первой части:

   # открываем текстовый файл
f = open('tom1.txt', "r", encoding="utf-8")
# закидываем его содержимое в переменную
text = f.read()
# выводим начало, чтобы убедиться, что всё считалось правильно
print(text[:300])
# переводим символы в нижний регистр, чтобы всё было одинаково
text = text.lower()
# подключаем встроенный модуль работы со строками
import string
# добавляем к стандартным знакам пунктуации кавычки и многоточие
spec_chars = string.punctuation + '«»\t—…’'
# очищаем текст от знаков препинания
text = "".join([ch for ch in text if ch not in spec_chars])
# подключаем регулярные выражения
import re
# меняем переносы строк на пробелы
text = re.sub('\n', ' ', text)
# убираем из текста цифры
text = "".join([ch for ch in text if ch not in string.digits])
# смотрим на результат
print(text[:300])
# из библиотеки обработки текста подключаем модуль для токенизации слов
from nltk import word_tokenize
# токенизируем текст
text_tokens = word_tokenize(text)
# подключаем библиотеку для работы с текстом
import nltk
# переводим токены в текстовый формат
# text = nltk.Text(text_tokens)
text = nltk.Text(text_tokens)
# подключаем статистику 
from nltk.probability import FreqDist
# и считаем слова в тексте по популярности
fdist = FreqDist(text)
# выводим первые 5 популярных слов
print(fdist.most_common
)
# подключаем модуль со стоп-словами
from nltk.corpus import stopwords
# добавляем русские и французские стоп-слова
russian_stopwords = stopwords.words("russian")
russian_stopwords += stopwords.words("french")
# перестраиваем токены, не учитывая стоп-слова
text_tokens = [token.strip() for token in text_tokens if token not in russian_stopwords]
# снова приводим токены к текстовому виду
text = nltk.Text(text_tokens)
# считаем заново частоту слов
fdist_sw = FreqDist(text)
# показываем самые популярные
print(fdist_sw.most_common)
# добавляем свои слова в этот список
russian_stopwords.extend(['это', 'что','всё','сказал', 'сказала','говорил','говорила'])
# перестраиваем токены, не учитывая стоп-слова
text_tokens = [token.strip() for token in text_tokens if token not in russian_stopwords]
# снова приводим токены к текстовому виду
text = nltk.Text(text_tokens)
# считаем заново частоту слов
fdist_sw = FreqDist(text)
# показываем самые популярные
# подключаем библиотеку для создания облака слов
from wordcloud import WordCloud
# и графический модуль, с помощью которого нарисуем это облако
import matplotlib.pyplot as plt
import matplotlib.pyplot as plt1
# переводим всё в текстовый формат
text_raw = " ".join(text)
# готовим размер картинки
wordcloud = WordCloud(width=1600, height=800).generate(text_raw)
plt.figure( figsize=(20,10), facecolor='k')
# добавляем туда облако слов
plt.imshow(wordcloud)
# выключаем оси и подписи
plt.axis("off")
# убираем рамку вокруг
plt.tight_layout(pad=0)
# выводим картинку на экран
plt.show()  
  

Нормальная форма слова — это то, как оно записано в словаре:

• для глаголов это будет неопределённая форма;
• для существительных — единственное число, именительный падеж;
• для прилагательных — единственное число, именительный падеж, мужской род.

После такой обработки слова «сказал», «сказали» и «скажут» превратятся в «сказать» — и у нас появится три одинаковых слова, вместо трёх разных. Для этого установим библиотеку с поддержкой русского языка pymorphy2:

pip install pymorphy2

Перед тем как продолжить, найдём в коде такую команду, чтобы добавить код после неё:

# токенизируем текст

text_tokens = word_tokenize(text)

Теперь подключаем библиотеку для нормализации и переводим все слова в нормальную форму:

   # подключаем библиотеку для нормализации слов
import pymorphy2
# добавляем анализатор слов
morph = pymorphy2.MorphAnalyzer()
# тут будут те же самые слова, что и в исходном тексте, но в нормальной форме
filtered_tokens = []
# перебираем все слова в исходном тексте
for token in text_tokens:
    # получаем нормальную форму текущего слова
    p = morph.parse(str(token))[0]
    # добавляем его в новый массив
    filtered_tokens.append(p.normal_form)  
  

Теперь нам нужно перевести в текстовый формат уже новые слова, поэтому меняем переменную в команде ниже:

# переводим токены в текстовый формат
text = nltk.Text(filtered_tokens)

И последнее, где нам нужно учесть работу с новой переменной, — это в перестройке токенов:

Вот картинка для понимания, где именно нужно заменить в коде название переменной:

Библиотека NLTK и токенизация

Дальше нам понадобится NLTK — мощная библиотека для обработки текста. Технически это даже не одна библиотека, а набор модулей, внутри которых тоже может быть разное, но для простоты назовём это так.

Токенизация — это сегментация, или разделение текста на отдельные компоненты, а токены — это и есть те самые компоненты. Так как мы ищем самые популярные слова, то нам нужно токенизировать на уровне слов. Например, если токенизировать по словам предложение «и швец, и жнец, и на дуде игрец», то токены будут такие: «и», «швец», «жнец», «на», «дуде», «игрец».

Важно помнить, что с точки зрения библиотеки, токены — это не строки, хотя они и хранятся там в таком виде. Чтобы можно было работать с ними как со строками, мы будем их отдельно приводить к этому виду.

Для установки библиотеки используем команду:

pip install nltk

Для установки отдельных модулей, например, word_tokenize, нам понадобится сделать такое:

1. В терминале VS Code выполнить команду python
   (или python3
   ). Запустится среда выполнения Python, в которой мы будем дальше работать.
2. Пишем и выполняем команду import nltk
   — она подгрузит библиотеку в Python.
3. После этого установим нужный модуль командой nltk.download('word_tokenize')
   . 
4. Также можем сразу установить второй модуль, который мы будем использовать: nltk.download('stopwords')
   .
5. Выходим из среды Python, набрав в консоли команду exit()
   .

Теперь найдём первые 5 самых популярных слов в тексте:

   # из библиотеки обработки текста подключаем модуль для токенизации слов
from nltk import word_tokenize
# токенизируем текст
text_tokens = word_tokenize(text)
# подключаем библиотеку для работы с текстом
import nltk
# переводим токены в текстовый формат
text = nltk.Text(text_tokens)
# подключаем статистику 
from nltk.probability import FreqDist
# и считаем слова в тексте по популярности
fdist = FreqDist(text)
# выводим первые 5 популярных слов
print(fdist.most_common
)  
  

Библиотеки Python для работы с NLP

NLTK

NLTK (Natural Language Toolkit)
— это одна из наиболее известных библиотек Python для обработки естественного языка. Она предоставляет возможности для классификации, токенизации, стемминга, разметки, анализа синтаксиса и семантики текста.

Пример использования NLTK:

  import nltk

text = "Hello, I am learning NLP with Python."
tokens = nltk.word_tokenize(text)
print(tokens)
  

spaCy

spaCy
— это еще одна популярная библиотека для NLP, которая предлагает высокопроизводительное решение для многих задач обработки естественного языка, таких как частеречная разметка, именованные сущности, связывание слов и векторное представление текста.

Пример использования spaCy:

  import spacy

nlp = spacy.load("en_core_web_sm")
doc = nlp("Hello, I am learning NLP with Python.")
for token in doc:
 print(token.text, token.pos_)
  

Python-разработчик: новая работа через 9 месяцев

Получится, даже если у вас нет опыта в IT

Получить
программу

Gensim

Gensim
— это библиотека Python для обработки текста, которая специализируется на тематическом моделировании и векторном представлении текста. Она широко используется для анализа больших объемов текстовой информации и построения моделей тематической классификации.

Пример использования Gensim:

  from gensim import corpora, models

documents = [
 "This is a sentence about NLP.",
 "Another sentence about natural language processing.",
 "A third sentence about text analysis."
]

texts = [[word for word in document.lower().split()] for document in documents]
dictionary = corpora. Dictionary(texts)
corpus = [dictionary.doc2bow(text) for text in texts]

lda_model = models. LdaModel(corpus, num_topics=2, id2word=dictionary, passes=15)
topics = lda_model.print_topics(num_words=4)
for topic in topics:
 print(topic)
  

Применение методов анализа текста

Существует множество методов, которые можно использовать для анализа текста, такие как:

• анализ частоты слов
• извлечение ключевых слов и фраз
• определение тональности текста (позитивный, негативный, нейтральный)
• анализ коллокаций и групп слов
• создание облака тегов
• анализ тематики текста

Пример использования Gensim для извлечения ключевых слов и фраз:

  import gensim
from gensim.summarization import keywords

text = "This is a sample text for text analysis using Python."
key_words = keywords(text, words=5)
print(key_words)
  

😉 Не бойтесь экспериментировать и применять различные методы анализа текста в зависимости от ваших потребностей.

Оптимизируем код

Так как нам нужно будет за один прогон получить три картинки с облаками слов, поменяем код так, чтобы это было сделать проще всего. Для этого нам нужно сделать две вещи:

1. Собрать в одном месте импорты нужных библиотек.
2. Превратить в функцию тот фрагмент кода, где происходит подготовка и формирование облака слов.

Логика работы будет такая: формируем три списка слов и по очереди вызываем функцию создания облака. Благодаря функции нам не придётся делать спагетти-код и дублировать три раза подряд одно и то же, только с разными переменными.

Соберём все команды импорта в начало скрипта — просто найдём их в коде и перенесём в начало:

   # подключаем встроенный модуль работы со строками
import string
# подключаем регулярные выражения
import re
# из библиотеки обработки текста подключаем модуль для токенизации слов
from nltk import word_tokenize
# подключаем библиотеку для нормализации слов
import pymorphy2
# подключаем библиотеку для работы с текстом
import nltk
# подключаем библиотеку для создания облака слов
from wordcloud import WordCloud
# и графический модуль, с помощью которого нарисуем это облако
import matplotlib.pyplot as plt
# подключаем статистику 
from nltk.probability import FreqDist  
  

Теперь найдём в коде такую строчку:

# переводим токены в текстовый формат

text = nltk. Text(filtered_tokens)

Начиная с этой команды скрипт обрабатывает наш текст, чтобы потом на его основе сформировать готовую картинку с облаком. Так как нужные команды идут до конца скрипта, то мы сделаем так:

1. Перед этой командой объявим новую функцию def text_cloud()
   .
2. В качестве параметра укажем переменную tokens
   — её у нас ещё нет, поэтому пусть будет как аргумент функции.
3. В этой функции меняем везде filtered_tokens
   на tokens
   , чтобы функция могла универсально обработать любой список слов, который мы ей дадим.

В итоге должен получиться такой код:

   def text_cloud(tokens):
    # переводим токены в текстовый формат
    text = nltk.Text(tokens)
    # считаем слова в тексте по популярности
    fdist = FreqDist(text)
    # выводим первые 5 популярных слов
    print(fdist.most_common
)
    # подключаем модуль со стоп-словами
    from nltk.corpus import stopwords
    # добавляем русские и французские стоп-слова
    russian_stopwords = stopwords.words("russian")
    russian_stopwords += stopwords.words("french")
    # перестраиваем токены, не учитывая стоп-слова
    text_tokens = [token.strip() for token in tokens if token not in russian_stopwords]
    # снова приводим токены к текстовому виду
    text = nltk.Text(text_tokens)
    # считаем заново частоту слов
    fdist_sw = FreqDist(text)
    # показываем самые популярные
    print(fdist_sw.most_common
)
    # добавляем свои слова в этот список
    russian_stopwords.extend(['это', 'что','всё','который', 'свой','говорить','сказать','думать','человек','ещё','весь','лицо','время','мочь','знать','видеть'])
    # перестраиваем токены, не учитывая стоп-слова
    text_tokens = [token.strip() for token in text_tokens if token not in russian_stopwords]
    # снова приводим токены к текстовому виду
    text = nltk.Text(text_tokens)
    # считаем заново частоту слов
    fdist_sw = FreqDist(text)
    # переводим всё в текстовый формат
    text_raw = " ".join(text)
    # готовим размер картинки
    wordcloud = WordCloud(width=1600, height=800).generate(text_raw)
    plt.figure( figsize=(20,10), facecolor='k')
    # добавляем туда облако слов
    plt.imshow(wordcloud)
    # выключаем оси и подписи
    plt.axis("off")
    # убираем рамку вокруг
    plt.tight_layout(pad=0)
    # выводим картинку на экран
    plt.show()  
  
 Чтобы убедиться, что всё работает, добавим в самый конец скрипта команду:
 
 Убираем лишнее
 Сейчас в тексте много лишнего, что будет мешать анализу:
 цифры,
 знаки препинания,
 большие и маленькие буквы,
 переносы строк.
 Исправим это с помощью встроенного модуля String — в нём уже есть почти вся пунктуация, которую мы дополним несколькими символами:
   # переводим символы в нижний регистр, чтобы всё было одинаково
text = text.lower()
# подключаем встроенный модуль работы со строками
import string
# добавляем к стандартным знакам пунктуации кавычки и многоточие
spec_chars = string.punctuation + '«»\t—…’'
# очищаем текст от знаков препинания
text = "".join([ch for ch in text if ch not in spec_chars])
# подключаем регулярные выражения
import re
# меняем переносы строк на пробелы
text = re.sub('\n', ' ', text)
# убираем из текста цифры
text = "".join([ch for ch in text if ch not in string.digits])
# смотрим на результат
print(text[:300])  
  
 
 Текст стал однородным: его теперь сложно читать, зато компьютеру будет легко распознать каждое слово. 
 Чистим текст от стоп-слов
 Стоп-слова в NLTK — это те слова, которые мешают правильно оценить весь текст.  К ним относятся:
 предлоги и союзы,
 местоимения,
 междометия,
 артикли,
 слова-связки.
 Чтобы избавиться от них, используем специальный модуль, в котором уже собраны все стоп-слова из разных языков.  Сразу добавим туда стоп-слова из французского языка, так как герои романа часто общаются друг с другом по-французски:
   # подключаем модуль со стоп-словами
from nltk.corpus import stopwords
# добавляем русские и французские стоп-слова
russian_stopwords = stopwords.words("russian")
russian_stopwords += stopwords.words("french")
# перестраиваем токены, не учитывая стоп-слова
text_tokens = [token.strip() for token in text_tokens if token not in russian_stopwords]
# снова приводим токены к текстовому виду
text = nltk.Text(text_tokens)
# считаем заново частоту слов
fdist_sw = FreqDist(text)
# показываем самые популярные
print(fdist_sw.most_common
)  
  
 
 Стало лучше, но появилась новая проблема: судя по первой десятке, герои слишком много говорят — «cказал», «сказала», «говорил».  Для чистоты эксперимента их тоже можно убрать из текста, поместив их в список стоп-слов.  Туда же отнесём «это» и «что»:
   # добавляем свои слова в этот список
russian_stopwords.extend(['это', 'чтò','всё','сказал', 'сказала','говорил','говорила'])
# перестраиваем токены, не учитывая стоп-слова
text_tokens = [token.strip() for token in text_tokens if token not in russian_stopwords]
# снова приводим токены к текстовому виду
text = nltk.Text(text_tokens)
# считаем заново частоту слов
fdist_sw = FreqDist(text)
# показываем самые популярные  
  
 
 Рисуем облако слов
 У нас всё готово, чтобы вывести слова в виде красивой картинки: чем чаще встречается слово, тем большим шрифтом оно будет написано.  Сделаем это с помощью библиотеки wordcloud, которую нужно будет установить отдельно:
 pip install wordcloud
   # подключаем библиотеку для создания облака слов
from wordcloud import WordCloud
# и графический модуль, с помощью которого нарисуем это облако
import matplotlib.pyplot as plt
# переводим всё в текстовый формат
text_raw = " ".join(text)
# готовим размер картинки
wordcloud = WordCloud(width=1600, height=800).generate(text_raw)
plt.figure( figsize=(20,10), facecolor='k')
# добавляем туда облако слов
plt.imshow(wordcloud)
# выключаем оси и подписи
plt.axis("off")
# убираем рамку вокруг
plt.tight_layout(pad=0)
# выводим картинку на экран
plt.show()  
  
 
 Точно так же получаем картинки для второго, третьего и четвёртого тома — просто меняем название файла в первой команде скрипта и запускаем код:
 
 
 
 Загружаем текст
 Мы всё будем делать в редакторе VS Code — он бесплатный, есть окно вывода сообщений и ошибок, а ещё он умеет сразу показывать сгенерированные картинки в отдельном окне.
 Также нам понадобятся все тома «Войны и мира»:
 Их нужно положить в ту же папку, где будет скрипт.
 Создаём новый python-файл, указываем в нём путь к файлу, потом загружаем в переменную и сразу проверяем, получилось или нет.  Для этого выводим первые 300 символов текста:
   # открываем текстовый файл
f = open('tom1.txt', "r", encoding="utf-8")
# закидываем его содержимое в переменную
text = f.read()
# выводим начало, чтобы убедиться, что всё считалось правильно
print(text[:300])  
  
 
 Видно, что файл считался нормально, всё на месте.  Ещё сразу становится понятно, что в тексте будет много французского языка — это тоже мы учтём при анализе.
 Что дальше
 То, что мы отобрали слова вручную, — иногда не самое лучшее решение.  Гораздо круче было бы автоматически отфильтровать тексты так, чтобы в первой десятке популярных слов из каждого тома не было ни одного одинакового слова.  Этим займёмся в следующий раз — нужно будет сильно кромсать и переделывать скрипт.
 Запускаем скрипт
 Сейчас у нас есть отсортированные слова, но нет картинок — всё потому, что мы не отправили их на обработку в функцию text_cloud().  Исправим это и добавим в самый конец скрипта такие команды:
# вызываем по очереди функцию создания облака тегов для каждого списка
text_cloud(noun_tokens)
text_cloud(adjf_tokens)
text_cloud(verb_tokens)
 Скрипт сначала сформирует первую картинку; когда мы её закроем, то покажет вторую, а когда закроем и это окно — появится третья. 
 Вот что у нас получилось в детальном рассмотрении первого тома «Войны и мира».  С существительными у библиотеки всё более-менее хорошо:
 
 А вот с прилагательными модуль дал сбой: «ваш» и «наш» он посчитал тоже прилагательными, как и Болконского.  Их можно добавить в стоп-лист, но для чистоты эксперимента мы ничего не трогали:
 
 С глаголами тоже всё хорошо — нет почти ни одного лишнего слова:
 
   # подключаем встроенный модуль работы со строками
import string
# подключаем регулярные выражения
import re
# из библиотеки обработки текста подключаем модуль для токенизации слов
from nltk import word_tokenize
# подключаем библиотеку для нормализации слов
import pymorphy2
# подключаем библиотеку для работы с текстом
import nltk
# подключаем библиотеку для создания облака слов
from wordcloud import WordCloud
# и графический модуль, с помощью которого нарисуем это облако
import matplotlib.pyplot as plt
# подключаем статистику 
from nltk.probability import FreqDist

# открываем текстовый файл
f = open('tom1.txt', "r", encoding="utf-8")
# закидываем его содержимое в переменную
text = f.read()
# выводим начало, чтобы убедиться, что всё считалось правильно
print(text[:300])
# переводим символы в нижний регистр, чтобы всё было одинаково
text = text.lower()
# добавляем к стандартным знакам пунктуации кавычки и многоточие
spec_chars = string.punctuation + '«»\t—…’'
# очищаем текст от знаков препинания
text = "".join([ch for ch in text if ch not in spec_chars])
# меняем переносы строк на пробелы
text = re.sub('\n', ' ', text)
# убираем из текста цифры
text = "".join([ch for ch in text if ch not in string.digits])
# смотрим на результат
print(text[:300])
# токенизируем текст
text_tokens = word_tokenize(text)
# добавляем анализатор слов
morph = pymorphy2.MorphAnalyzer()

# новые переменные для существительных, прилагательных и глаголов 
noun_tokens = []
adjf_tokens = []
verb_tokens = []

# перебираем все слова в исходном тексте
for token in text_tokens:
    # получаем нормальную форму текущего слова
    p = morph.parse(str(token))[0]
    if "NOUN" in p.tag:
        # добавляем его в массив c существительными
        noun_tokens.append(p.normal_form)
    elif "ADJF" in p.tag or "ADJS" in p.tag:
        # добавляем его в массив c прилагательными
        adjf_tokens.append(p.normal_form)
    elif "VERB" in p.tag or "INFN" in p.tag:
        # добавляем его в массив c глаголами
        verb_tokens.append(p.normal_form)



def text_cloud(tokens):
    # переводим токены в текстовый формат
    text = nltk.Text(tokens)
    # считаем слова в тексте по популярности
    fdist = FreqDist(text)
    # выводим первые 5 популярных слов
    print(fdist.most_common# добавляем свои слова в этот список
russian_stopwords.extend(['это', 'чтò','всё','сказал', 'сказала','говорил','говорила'])
# перестраиваем токены, не учитывая стоп-слова
text_tokens = [token.strip() for token in text_tokens if token not in russian_stopwords]
# снова приводим токены к текстовому виду
text = nltk.Text(text_tokens)
# считаем заново частоту слов
fdist_sw = FreqDist(text)
# показываем самые популярные)
    # подключаем модуль со стоп-словами
    from nltk.corpus import stopwords
    # добавляем русские и французские стоп-слова
    russian_stopwords = stopwords.words("russian")
    russian_stopwords += stopwords.words("french")
    # перестраиваем токены, не учитывая стоп-слова
    text_tokens = [token.strip() for token in tokens if token not in russian_stopwords]
    # снова приводим токены к текстовому виду
    text = nltk.Text(text_tokens)
    # считаем заново частоту слов
    fdist_sw = FreqDist(text)
    # показываем самые популярные
    print(fdist_sw.most_common)
    # добавляем свои слова в этот список
    russian_stopwords.extend(['это', 'что','всё','который', 'свой','говорить','сказать','думать','человек','ещё','весь','лицо','время','мочь','знать','видеть'])
    # перестраиваем токены, не учитывая стоп-слова
    text_tokens = [token.strip() for token in text_tokens if token not in russian_stopwords]
    # снова приводим токены к текстовому виду
    text = nltk.Text(text_tokens)
    # считаем заново частоту слов
    fdist_sw = FreqDist(text)
    # переводим всё в текстовый формат
    text_raw = " ".join(text)
    # готовим размер картинки
    wordcloud = WordCloud(width=1600, height=800).generate(text_raw)
    plt.figure( figsize=(20,10), facecolor='k')
    # добавляем туда облако слов
    plt.imshow(wordcloud)
    # выключаем оси и подписи
    plt.axis("off")
    # убираем рамку вокруг
    plt.tight_layout(pad=0)
    # выводим картинку на экран
    plt.show()

# вызываем по очереди функцию создания облака тегов для каждого списка
text_cloud(noun_tokens)
text_cloud(adjf_tokens)
text_cloud(verb_tokens)  
  
 Сравниваем слова из четырёх томов
 После запуска скрипта видно, что результат сильно отличается от того, что мы получили в первый раз: нормализация расставила всё по местам и показала настоящую частоту слов. 
 Прогоним через скрипт все тома и посмотрим, есть ли в облаках одинаковые слова, которые забивают собой все остальные:
 
 
 
 
 Видно, что «который», «свой», «сказать» и «говорить» — самые частые слова в каждом томе.  Это понятно: для Толстого это, по сути, служебные слова.  Но если они есть везде, то, избавившись от них, мы получим более точное отражение того, что происходит в книгах.
 У нас есть команда в скрипте, которая убирает ненужные слова из текста:
 Поменяем этот список и добавим в него такие слова:
 который,
 свой,
 говорить,
 сказать,
 думать,
 человек,
 ещё,
 весь.
 
 
 
 
 У нас проявились ещё несколько кандидатов для добавления в фильтр, которые перетягивают внимание на себя:
 лицо,
 время,
 мочь,
 знать,
 видеть.
 Добавим их в фильтр и запустим всё заново:
 
 
 
 
 Видно, что в первом томе мы знакомимся со всеми героями понемногу, потом фокусируемся вокруг злоключений Пьера и Наташи, далее в третьем томе наконец-то им составит компанию Наполеон.  А в четвёртом томе главными героями снова станут Пьер и Наташа.  Нет сомнений, что «Война и мир» гораздо больше про мир, чем про войну. 
 Сортируем слова
 Чтобы разделить существительные, прилагательные и глаголы, нам понадобится дополнительный элемент в библиотеке pymorphy2 — свойство tag
 .  В нём хранится дополнительная информация о слове — тип, число, род и другая информация. 
 Например, если проанализированное слово хранится в переменной p, то проверить, существительное оно или нет, можно так:
if "NOUN" in p.tag:
 # это — существительное
 Проще говоря, нам нужно проверить, есть ли нужное свойство среди всех свойств внутри тега.  Чтобы разобраться, как в библиотеке кодируются разные части речи,  идём на сайт с документацией библиотеки 
 и смотрим таблицу «Часть речи»:
 
 Чтобы мы сразу могли отправлять найденные части речи по своим спискам, сразу после добавления анализатора слов заведём новые переменные:
   # новые переменные для существительных, прилагательных и глаголов 
noun_tokens = []
adjf_tokens = []
verb_tokens = []  
  
 Теперь переберём все слова в исходном тексте и сразу посмотрим, в какой список их отправлять.  Для этого посмотрим, какие признаки слов есть в тегах, и в зависимости от этого примем решение:
   # перебираем все слова в исходном тексте
for token in text_tokens:
    # получаем нормальную форму текущего слова
    p = morph.parse(str(token))[0]
    if "NOUN" in p.tag:
        # добавляем его в массив c существительными
        noun_tokens.append(p.normal_form)
    elif "ADJF" in p.tag or "ADJS" in p.tag:
        # добавляем его в массив c прилагательными
        adjf_tokens.append(p.normal_form)
    elif "VERB" in p.tag or "INFN" in p.tag:
        # добавляем его в массив c глаголами
        verb_tokens.append(p.normal_form)  
  
 Использование библиотек для текстового анализа
 В Python существует несколько библиотек, которые могут использоваться для текстового анализа.  Некоторые из наиболее популярных библиотек включают:
 NLTK (Natural Language Toolkit)
 TextBlob
 spaCy
 Gensim
 TfidfVectorizer (из библиотеки scikit-learn)
 Пример использования TextBlob для определения полярности и субъективности текста:
  from textblob import TextBlob

text = "I love Python programming!"
blob = TextBlob(text)
print(blob.sentiment)
  
 Python-разработчик: новая работа через 9 месяцев
 Получится, даже если у вас нет опыта в IT
  Получить
 программу 
 
 
 Что делаем
 Сегодня мы проанализируем текст всех томов «Войны и мира» и посмотрим, изменятся ли самые частые слова, как это будет выглядеть в облаке.  Интересно, можно ли по таким облакам хотя бы примерно понять общее настроение или содержание текста.
 Логика будет простая:
 Скачиваем четыре тома, каждый отдельным текстовым файлом.
 Пишем алгоритм, который проанализирует слова в первом томе.
 Генерируем для него облако слов.
 Меняем имя файла в программе и получаем картинки для трёх оставшихся томов.
 Смотрим, что получилось, и сравниваем картинки между собой.
 Вместо художественного текста анализировать так можно что угодно: статьи «Кода», записи в дневнике или инструкцию от пылесоса.