Word stopped counting words

The following is a list of stop words that are frequently used in english language.

Where these stops words normally include prepositions, particles, interjections, unions, adverbs, pronouns, introductory words, numbers from 0 to 9 (unambiguous), other frequently used official, independent parts of speech, symbols, punctuation. Relatively recently, this list was supplemented by such commonly used on the Internet sequences of symbols as www, com, http, etc.

There are 2 views of stop words for english language: table and list. Just use the view which is the most convenient to you.

For the external usage, you can always download stop words for english as XML, TXT or JSON formats.

Время на прочтение
11 мин

Количество просмотров 12K

Автор статьи — Виктория Ляликова.

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

Рассмотрим задачу обработки естественного языка (NLP — Natural Lanuage Processing) на примере классификации психического здоровья для определения депрессии по комментариям в Reddit. Посмотрим на наш датасет:

import pandas as pd
data_depression = pd.read_csv('D:/vika/datasets/depression_dataset_reddit_cleaned.csv')
data_depression

Посмотрим, например, на какую-нибудь одну запись:

‘sleep is my greatest and most comforting escape whenever i wake up these day the literal very first emotion i feel is just misery and reminding myself of all my problem i can t even have a single second to myself it s like waking up everyday is just welcoming yourself back to hell’.

Данный комментарий классифицируется как наличие депрессии у человека.

Далее посмотрим на гистограмму распределения.

import seaborn as sns
sns.countplot(data=data_depression, x="is_depression")

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

Сначала необходимо импортировать библиотеку NLTK, которая является ведущей для создания программ по обработке естественного языка на Python. И рассмотрим основные методы данного инструмента.

Также нам понадобится загрузить модуль RE, который является модулем по работе с регулярными выражениями и также помогает работать с текстом. Данный модуль позволяет производить поиск, замену, анализ и другие операции по работе с текстом.

import nltk
import re

nltk.download("stopwords") # поддерживает удаление стоп-слов
nltk.download('punkt') # делит текст на список предложений
nltk.download('wordnet') # проводит лемматизацию
from nltk.corpus import stopwords

Рассмотрим основные шаги, которые необходимы для обработки текста.

1. Очистка текста от неалфавитных символов. Функция re.sub позволяет заменить все, что подходит под шаблон на указанную строку. Например, вот так можно заменить все, что не является словами на пробелы:

re.sub("[^a-zA-Z]"," ",text)

1. Токенизация. Данный метод позволяет разделить текст на так называемые токены, то есть на слова или предложения.

nltk.word_tokenize(text,language = "english")

1. Лемматизация. Позволяет привести словоформу к лемме — ее нормальной (словарной) форме. Другими словами, лемматизация схожа с выделением основы каждого слова в предложении. Она обычно выполняется простым поиском форм в таблице. Кроме того, можно добавить некоторые пользовательские правила для анализа слов.

lemmatize = nltk.WordNetLemmatizer()
lemmatize.lemmatize(word) for word in text

1. Удаление стоп-слов. Под стоп-словами обычно понимаются артикли, междометия, союзы и т.д., которые не несут смысловой нагрузки. При применении алгоритмов машинного обучения такие слова могут добавить много шума, поэтому лучше избавляться от них. В NLTK есть предустановленный список стоп-слов.

lemmatize.lemmatize(word) for word in text if not word in set(stopwords.words("stopwords"))

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

В пакете scikit-learn есть модуль CountVectorizer, который преобразовывает входной текст в матрицу, значениями которой являются количества вхождения данного ключа(слова) в текст. Таким образом, мы получим матрицу, размерность которой будет равна количеству всех слов, умноженных на количество документов. И элементами матрицы будут числа, которые означают, сколько раз всего слово встретилось в тексте.

Также популярным методом для векторизации текста является метод TF-IDF, который является статистической мерой для оценки важности слова в документе.

В тексте большого объема некоторые слова могут присутствовать очень часто, но при этом не нести никакой значимой информации о фактическом содержании текста (документа). Если такие данные передавать непосредственно классификатору, то такие частые термины могут затенять частоты более редких, но при этом более интересных терминов. Для того, чтобы этого избежать, достаточно разделить количество употреблений каждого слова в документе на общее количество слов в документе, это есть TF — частота термина. Термин IDF (inverse document frequency) обозначает обратную частоту термина (инверсия частоты) с которой некоторое слово встречается в документах. IDF позволяет измерить непосредственную важность термина.

Тогда TF-IDF вычисляется следующим образом:

TF-IDF(term)=TF(term)*IDF(term)

В итоге код по работе с текстом выглядит следующим образом,

new_text = []
for i in data_depression.clean_text:
    #удаляем неалфавитные символы
    text = re.sub("[^a-zA-Z]"," ",i) 
    # токенизируем слова
    text = nltk.word_tokenize(text,language = "english")
    # лемматирзируем слова
    text = [lemmatize.lemmatize(word) for word in i]
    # соединяем слова
    text = "".join(text)
    new_text.append(text)

В данной задаче текст будем преобразовывать в набор цифр с помощью модуля CountVectorizer для получения матрицы, содержащей 0 и 1.

# импортируем модуль
from sklearn.feature_extraction.text import CountVectorizer
count = CountVectorizer(stop_words="english")
# проводим преобразование текста
matrix = count.fit_transform(new_text).toarray()

Если мы ходим преобразовать текст, используя метод TF-IDF, тогда можно поступить следующим образом:

# импортируем модуль TfidfVectorizer
from sklearn.feature_extraction.text import TfidfVectorizer
tfidf_vectorizer = TfidfVectorizer(stop_words="english")
#преобразуем текст
values = tfidf_vectorizer.fit_transform(new_text)

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

Определим вектор с данными для обучения и вектор правильных ответов. 

X=matrix
y = data_depression["is_depression"].values
Далее разделим выборку на тестовую и обучающую
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(X, y, test_size = 0.33, random_state = 42)

Рассмотрим самый известный алгоритм — наивный классификатор Байеса. Данный алгоритм является одним из самых простых алгоритмов классификации, но при этом часто может работать не хуже более сложных алгоритмов. Метрики качества работы алгоритмов будут приведено ниже. Пока буду приводить только точность алгоритмов.

from sklearn.naive_bayes import GaussianNB
nb = GaussianNB()
result_bayes = nb.fit(x_train, y_train)
nb.score(x_test,y_test)
0.8436520376175548

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

from sklearn.linear_model import LogisticRegression
logreg = LogisticRegression()
result_logreg = logreg.fit(x_train, y_train)
logreg.score(x_test,y_test)
0.9564655172413793

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

from sklearn import svm
metodsvm = svm.SVC()
result_svm = metodsvm.fit(x_train, y_train)
metodsvm.score(x_test, y_test)
0.9543103448275863

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

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

#адаптивный бустинг

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.ensemble import AdaBoostClassifier

modelClf = AdaBoostClassifier(base_estimator=DecisionTreeClassifier(max_depth=2), n_estimators=100, random_state=42)

X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size = 0.33, random_state = 42)

modelclf_fit = modelClf.fit(X_train, y_train)
modelClf.score(X_valid, y_valid)
0.9361285266457681

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

# градиентный бустинг

from sklearn.model_selection import train_test_split
# импортируем библиотеку
from sklearn.ensemble import GradientBoostingClassifier

modelClf = GradientBoostingClassifier(max_depth=2, n_estimators=150,random_state=12, learning_rate=1)

X_train, X_valid, y_train, y_valid = train_test_split(X, y,
                                                      test_size=0.3, random_state=12)

modelClf.fit(X_train, y_train)
modelClf.score(X_valid, y_valid)
0.928448275862069

И напоследок хочется рассмотреть алгоритм работы простой нейронной сети (многослойный персептрон), в которой будет 2 полносвязнных слоя и 1 выходной с 1 выходом. Чтобы смоделировать нейронную сеть в python, нам понадобится фреймворк Keras, который является оболочкой над Tensorflow. 

В Keras для построения моделей нейронных сетей (models) мы собираем слои (layers). Для описания стандартных архитектур нейронных сетей в Keras уже существуют предопределенные классы для слоев:

• Dense() – полносвязный слой;

• Conv1D, Conv2D, Conv3D – сверточные слои;

• Conv2DTranspose, Conv3DTranspose – транспонированные (обратные) сверточные слои;

• SimpleRNN, LSTM, GRU – рекуррентные слои;

• MaxPooling2D, Dropout, BatchNormalization – вспомогательные слои

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

Типичный процесс использования Keras для построения нейронной сети можно описать так:

1. Определение обучающих данных: входные и целевые векторы

2. Определение слоев сети (модель), отображающих входные данные в целевые

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

4. Выполнение итераций по обучающим данным вызовом метода fit() и модели.

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

Загружаем необходимые библиотеки:

from keras import models
from keras import layers
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

1. Получаем обучающую и тестовую выборку:

x_train, x_test, y_train, y_test = train_test_split(X, y, test_size = 0.33, random_state = 42)

2. Сначала создаем пустую модель Sequential:

model = models.Sequential()

Теперь в пустую модель нейронной сети можно добавлять слои. Добавим 2 полносвязных слоя с 64 выходными нейронами и активационной функцией Relu (фактор нелинейности). Функция relu является самой популярной функцией в глубоком обучении, но, конечно, можно использовать и другие. Первому слою надо обязательно передать ожидаемую форму входных данных, т.е. размер входного вектора, это указывается в параметре input_shape.

model.add(layers.Dense(64,activation='relu',input_shape=(voc_len,)))
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(1, activation = 'sigmoid'))

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

3. После того, как модель создана, необходимо настроить процесс ее обучения с помощью вызова метода compile

from keras import optimizers
model.compile(optimizer='rmsprop',loss='binary_crossentropy',metrics=['accuracy'])

Объект optimizer определяет процедуру обучения, а именно оптимизатор алгоритма градиентного спуска. Доступны оптимизаторы SGD, RMSprop, Adam, Adadelta, Adagrad, Adamax, Nadam, Ftrl.

Объект loss — это функция, которая минимизируется в процессе обучения. Среди распространенных вариантов: среднеквадратичная ошибка (mse), categorical_crossentropy, binary_crossentropy. 

Объект metrics используется для мониторинга обучения. 

4. Для обучения модели необходимо вызвать метод fit(). Задаем тренировочные данные, количество эпох для обучения, валидационные данные для отслеживания производительности модели, что позволит отобразить значения функции потерь и метрики в режиме вывода для передаваемых данных в конце каждой эпохи. Зададим 20 эпох, чтобы потом можно было найти оптимальное количество эпох, которое необходимо для обучения.

history=model.fit(x_train, y_train, epochs=20,batch_size=512,validation_data=(x_test,y_test))

Вызов метода fit вернет нам объект history, с помощью которого можно получить данные обо всем происходящем в процессе обучения.

history_dict = history.history
history_dict.keys()
dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])

Теперь можно вывести графики потерь и точности на этапах обучения и проверки

# построение графика потери на этапах проверки и обучения
loss_values = history_dict['loss']
val_loss_values = history_dict['val_loss']
epochs = range(1, len(history_dict['accuracy'])+1)

# построение графика потери на этапах проверки и обучения
loss_values = history_dict['loss']
val_loss_values = history_dict['val_loss']
epochs = range(1, len(history_dict['accuracy'])+1)

plt.plot(epochs, loss_values, 'bo', label = 'Потери на этапе обучения')
plt.plot(epochs, val_loss_values, 'b', label = 'Потери на этапе проверки')
plt.title('Потери на этапах обучения и проверки')
plt.xlabel('Эпохи')
plt.ylabel('Потери')
plt.legend()
plt.show()

# построение графика точности на этапах обучения и проверки
acc_values = history_dict['accuracy']
val_acc_values = history_dict['val_accuracy']
plt.plot(epochs, acc_values, 'bo', label = 'Точность на этапе обучения')
plt.plot(epochs, val_acc_values, 'b', label = 'Точность на этапе проверки')
plt.title('Точность на этапах обучения и проверки')
plt.xlabel('Эпохи')
plt.ylabel('Точность')
plt.legend()
plt.show()

Посмотрев на графики, можно увидеть, что на этапе обучения потери снижаются с каждой эпохой, а точность растет. Как раз такого поведения и можно ожидать от оптимизации градиентным спуском, та величина, которую мы минимизируем, должна становиться все меньше с каждой итерацией. Но это не относится к потерям и точности на этапе проверки, можно заметить, что здесь пик был достигнут где-то на 4-5 эпохе. И, начиная с пятой эпохи, наблюдается переобучение, которое выражается в том, что функция потерь начинает расти. Такой картины стоило ожидать, так как модель, которая показывает хорошие результаты на обучающих данных, не обязательно будет показывать такие же хорошие результаты на данных, которых никогда не видела. 

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

Y_pred=model.predict(x_test)
# задаем порог 0,5 для классификации текста
Y_pred=(Y_pred>=0.5).astype("int")
from sklearn.metrics import confusion_matrix
from sklearn.metrics import classification_report
print(classification_report(y_test,Y_pred))
print(confusion_matrix(y_test,Y_pred))

Результаты работы всех алгоритмов можно увидеть в таблице

Посмотрев на данную сравнительную таблицу, можно сказать, что классификатор Байеса, к сожалению, показал самые плохие результаты с точностью 0,84. У алгоритма адаптивного бустинга одинаковые показатели по всем метрикам, равные 0.94. Это связано с тем, что целью данного алгоритма является улучшение производительности алгоритмов. На мой взгляд, можно выделить 3 алгоритма, которые хорошо справились с задачей — это логистическая регрессия, метод опорных векторов и многослойный персептрон с точностью 0,95.

---

Приглашаем на открытое занятие «Пишем первую нейронную сеть». На нем рассмотрим основные этапы создания и обучения своей первой нейронной сети и попробуем решить известную задачу классификации MNIST полносвязной и сверточной нейронными сетями на примере фреймворка PyTorch. Регистрация — по ссылке.

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

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

Токенизация

Токен  —  это последовательность символов в документе, имеющая значение для анализа. Обычно это отдельные слова, но не всегда. Документ — это коллекция текста. Им может быть твит, книга или что-то еще. Признаки хороших токенов:

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

Пример: токенизация

import re

def tokenize(text):

    text = text.lower()

    text = re.sub(r'[^a-zA-Z ^0-9]', '', str(text))

    return text.split()

# Используем оригинал текста выше

tokens = tokenize(sample_text) 

tokens[:10]

____________________________________________________________________

['a',  'token',  'is',  'a',  'sequence',  'of',  'characters',  'in',  'a',  'document']

Подсчёт слов

Теперь, когда у нас есть токены, мы можем приступить к самому простому анализу. Подсчитаем количество слов через Counter.

from collections import Counter

def word_counter(tokens):

    word_counts = Counter()

    word_counts.update(tokens)

    return word_countsword_count = 

word_counter(tokens)

word_count.most_common(5)

____________________________________________________________________

[('a', 7), ('of', 4), ('in', 4), ('be', 4), ('an', 3)]

И отобразим на гистограмме:

import matplotlib.pyplot as plt

x = list(word_count.keys())[:10]

y = list(word_count.values())[:10]

plt.bar(x, y)

plt.show();

3. Состав документа

Количество слов может быть полезно, но обычно требуется более глубокий анализ, отвечающий на вопросы бизнеса, особенно когда данные состоят не из одного документа. Мы можем настроить себя на успех, создав Pandas DataFrame, содержащий функции, возвращающие:

• Количество и процент документов с токеном. 
• Количество токенов.
• Их ранг по частотности употребления по отношению к другим токенам. 
• Процент токенов от общего состава документа. 
• Текущую сумму этих процентов.

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

import pandas as pddef count(docs):

  
    word_counts = Counter()

    appears_in = Counter()

    total_docs = len(docs)

    
    for doc in docs:

        word_counts.update(doc)

        appears_in.update(set(doc))

        
    temp = list(zip(word_counts.keys(), word_counts.values()))

    
    # Колонки слов и количества

    wc = pd.DataFrame(temp, columns = ['word', 'count'])

    
    # Колонка ранга

    wc['rank'] = wc['count'].rank(method='first', ascending=False)

    
    # Колонка с общим процентом

    total = wc['count'].sum()

    wc['pct_total'] = wc['count'].apply(lambda x: x / total)

    
    # Колонка с кумулятивным общим процентом

    wc = wc.sort_values(by='rank')

    wc['cul_pct_total'] = wc['pct_total'].cumsum()

    
    # Появляется в колонке

    t2 = list(zip(appears_in.keys(), appears_in.values()))

    ac = pd.DataFrame(t2, columns=['word', 'appears_in'])

    wc = ac.merge(wc, on='word')

    
    # Появляется в колонке процентов

    wc['appears_in_pct'] = wc['appears_in'].apply(lambda x: x / total_docs)



  


                       
  




    
    
    return wc.sort_values(by='rank')

  
wc = count([tokens])wc.head()

С помощью DataFrame мы видим график функции распределения вероятностей, показывающий, как ранг токена связан с совокупным составом наших документов:

import seaborn as sns

sns.lineplot(x = 'rank', y = 'cul_pct_total', data = wc)

plt.show();

Из графика видно, что 13 наиболее употребимых токенов составляют 45% документа, а после распределение выглядит довольно равномерным. Мы можем увидеть относительный процент этих токенов в составе документа в виде сплошных занимаемых ими участков документа:

import squarify

wc_top13 = wc[wc['rank'] <= 13]

squarify.plot(sizes=wc_top13['pct_total'], label=wc_top13['word'], alpha=.8 )

plt.axis('off')

plt.show();

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

4. Введение в SpaCy

SpaСy  —  свободная, открытая библиотека Python для решения передовых задач NLP, разработанная Explosion. Она не хранит повторяющиеся компоненты документов в разных структурах данных. Вместо этого SpaСy индексирует компоненты и хранит уточняющую информацию. Поэтому её считают эффективнее в проектах производственного класса, чем библиотеки вроде NLTK. Токены в SpaCy:

import spacy

nlp = spacy.load("en_core_web_lg")

def spacy_tokenize(text):

    doc = nlp.tokenizer(text)

    return [token.text for token in doc]

spacy_tokens = spacy_tokenize(sample_text)

spacy_tokens[:10]

____________________________________________________________________

['a',  'token',  'is',  'a',  'sequence',  'of',  'characters',  'in',  'a',  'document']

5. Стоп-слова

Слова “I”, “and”, “of” и тому подобные почти не имеют смысловой нагрузки. Мы называем их стоп-словами и в анализ не включаем. Большинство библиотек имеют встроенный список часто используемых английских слов. Союзов, артиклей, наречий, предлогов и общеупотребимых глаголов. Однако лучшая практика  —  настройка списка под задачу. 

Пример удаления стоп-слов:

spacy_stopwords = spacy.lang.en.stop_words.STOP_WORDS

def remove_stopwords(tokens):

    cleaned_tokens = []

    
    for token in tokens:

        if token not in spacy_stopwords:

            cleaned_tokens.append(token)

    
    return cleaned_tokens

cleaned_tokens = remove_stopwords(spacy_tokens)

cleaned_tokens[:10]

____________________________________________________________________

['A', 'token', 'sequence', 'characters', 'document', 'useful', 'analytical', 'purpose', '.', 'Often']



  


                       
  

6. Леммы

Лемматизация  —  поиск леммы слова или корневого слова. Говоря простым языком, лемма — это то слово, которое можно найти в словаре. Например, бег, бежит, бегущий, бежал  —  формы одной и той же лексемы (слова) с леммой “бег”. Пример лемматизации:

def spacy_lemmatize(text):

    doc = nlp.tokenizer(text)

    return [token.lemma_ for token in doc]

spacy_lemmas = spacy_lemmatize(sample_text)

spacy_lemmas[:10]

____________________________________________________________________

['A', 'token', 'be', 'a', 'sequence', 'of', 'character', 'in', 'a', 'document']

Заключение

Токены, состав документа, стоп-слова, леммы  —  все они играют свою роль в обработке естественного языка, хотя они довольно просты сами по себе. Мой следующий пост NLP в Python: представления вектора погрузит нас глубже в тему NLP.

Jupyter Notebook на Github

У меня есть функция в NLTK для создания списка соответствия, который будет выглядеть

concordanceList = ["this is a concordance string something", 
               "this is another concordance string blah"] 

и у меня есть другая функция, которая возвращает словарь счетчика с количеством каждого слова в concordanceList

def mostCommonWords(concordanceList):
  finalCount = Counter()
  for line in concordanceList:
    words = line.split(" ")
    currentCount = Counter(words)
    finalCount.update(currentCount)
  return finalCount

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

mostCommonWords(concordanceList).most_common(10)

результат не просто {«the»: 100, «is»: 78, «that»: 57}.

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

stopWordCounter = Counter(the=1, that=1, so=1, and=1)
processedWordCounter = mostCommonWords(concordanceList) & stopWordCounter

который должен установить значения счетчика для всех стоп-слов в 1, но это выглядит странно.

Изменить: Кроме того, у меня возникают проблемы на самом деле сделать такой stopWordCounter, потому что, если я хочу включить зарезервированные слова, такие как «и», я получаю недопустимую синтаксическую ошибку. Счетчики имеют простые в использовании методы объединения и пересечения, которые делают задачу довольно простой; Есть ли эквивалентные методы для словарей?

from collections import Counter

from textblob import TextBlob

from nltk.stem.porter import PorterStemmer

from nltk.corpus import stopwords

import re

from nltk.tokenize import word_tokenize

from bs4 import BeautifulSoup

import urllib.request

import nltk

s = input('Enter the file name which contains a sentence: ')

file1 = open(s)

sentence = file1.read()

file1.close()

p = input('Enter the file name which contains a paragraph: ')

file2 = open(p)

paragraph = file2.read()

file2.close()

url = input('Enter URL of Webpage: ')

print('n')

url_request = urllib.request.Request(url)

url_response = urllib.request.urlopen(url)

webpage_data = url_response.read()

soup = BeautifulSoup(webpage_data, 'html.parser')

print('<------------------------------------------Initial Contents of Sentence are-------------------------------------------> n')

print(sentence)

print('n')

print('<------------------------------------------Initial Contents of Paragraph are-------------------------------------------> n')

print(paragraph)

print('n')

print('<------------------------------------------Initial Contents of Webpage are---------------------------------------------> n')

print(soup)

print('n')

web_page_paragraph_contents = soup('p')

web_page_data = ''

for para in web_page_paragraph_contents:

    web_page_data = web_page_data + str(para.text)

print('<------------------------------------------Contents enclosed between the paragraph tags in the web page are---------------------------------------------> n')

print(web_page_data)

print('n')

sentence_without_punctuations = re.sub(r'[^ws]', '', sentence)

paragraph_without_punctuations = re.sub(r'[^ws]', '', paragraph)

web_page_paragraphs_without_punctuations = re.sub(

    r'[^ws]', '', web_page_data)

print('<------------------------------------------Contents of sentence after removing punctuations---------------------------------------------> n')

print(sentence_without_punctuations)

print('n')

print('<------------------------------------------Contents of paragraph after removing punctuations---------------------------------------------> n')

print(paragraph_without_punctuations)

print('n')

print('<------------------------------------------Contents of webpage after removing punctuations-----------------------------------------------> n')

print(web_page_paragraphs_without_punctuations)

print('n')

sentence_after_tokenizing = word_tokenize(sentence_without_punctuations)

paragraph_after_tokenizing = word_tokenize(paragraph_without_punctuations)

webpage_after_tokenizing = word_tokenize(

    web_page_paragraphs_without_punctuations)

print('<------------------------------------------Contents of sentence after tokenizing----------------------------------------------> n')

print(sentence_after_tokenizing)

print('n')

print('<------------------ ------------------------Contents of paragraph after tokenizing---------------------------------------------> n')

print(paragraph_after_tokenizing)

print('n')

print('<------------------------------------------Contents of webpage after tokenizing-----------------------------------------------> n')

print(webpage_after_tokenizing)

print('n')

nltk.download('stopwords')

nltk_stop_words = stopwords.words('english')

sentence_without_stopwords = [

    i for i in sentence_after_tokenizing if not i.lower() in nltk_stop_words]

paragraph_without_stopwords = [

    j for j in paragraph_after_tokenizing if not j.lower() in nltk_stop_words]

webpage_without_stopwords = [

    k for k in webpage_after_tokenizing if not k.lower() in nltk_stop_words]

print('<------------------------------------------Contents of sentence after removing stopwords---------------------------------------------> n')

print(sentence_without_stopwords)

print('n')

print('<------------------------------------------Contents of paragraph after removing stopwords---------------------------------------------> n')

print(paragraph_without_stopwords)

print('n')

print('<------------------------------------------Contents of webpage after removing stopwords-----------------------------------------------> n')

print(webpage_without_stopwords)

print('n')

stemmer = PorterStemmer()

sentence_after_stemming = []

paragraph_after_stemming = []

webpage_after_stemming = [] 

for word in sentence_without_stopwords:

    sentence_after_stemming.append(stemmer.stem(word))

for word in paragraph_without_stopwords:

    paragraph_after_stemming.append(stemmer.stem(word))

for word in webpage_without_stopwords:

    webpage_after_stemming.append(stemmer.stem(word))

print('<------------------------------------------Contents of sentence after doing stemming---------------------------------------------> n')

print(sentence_after_stemming)

print('n')

print('<------------------------------------------Contents of paragraph after doing stemming---------------------------------------------> n')

print(paragraph_after_stemming)

print('n')

print('<------------------------------------------Contents of webpage after doing stemming-----------------------------------------------> n')

print(webpage_after_stemming)

print('n')

final_words_sentence = []

final_words_paragraph = []

final_words_webpage = []

for i in range(len(sentence_after_stemming)):

    final_words_sentence.append(0)

    present_word = sentence_after_stemming[i]

    b = TextBlob(sentence_after_stemming[i])

    if str(b.correct()).lower() in nltk_stop_words:

        final_words_sentence[i] = present_word

    else:

        final_words_sentence[i] = str(b.correct())

print('<------------------------------------------Contents of sentence after correcting misspelled words-----------------------------------------------> n')

print(final_words_sentence)

print('n')

for i in range(len(paragraph_after_stemming)):

    final_words_paragraph.append(0)

    present_word = paragraph_after_stemming[i]

    b = TextBlob(paragraph_after_stemming[i])

    if str(b.correct()).lower() in nltk_stop_words:

        final_words_paragraph[i] = present_word

    else:

        final_words_paragraph[i] = str(b.correct())

print('<------------------------------------------Contents of paragraph after correcting misspelled words-----------------------------------------------> n')

print(final_words_paragraph)

print('n')

for i in range(len(webpage_after_stemming)):

    final_words_webpage.append(0)

    present_word = webpage_after_stemming[i]

    b = TextBlob(webpage_after_stemming[i])

    if str(b.correct()).lower() in nltk_stop_words:

        final_words_webpage[i] = present_word

    else:

        final_words_webpage[i] = str(b.correct())

print('<------------------------------------------Contents of webpage after correcting misspelled words-----------------------------------------------> n')

print(final_words_webpage)

print('n')

sentence_count = Counter(final_words_sentence)

paragraph_count = Counter(final_words_paragraph)

webpage_count = Counter(final_words_webpage)

print('<------------------------------------------Frequency of words in sentence ---------------------------------------------> n')

print(sentence_count)

print('n')

print('<------------------------------------------Frequency of words in paragraph ---------------------------------------------> n')

print(paragraph_count)

print('n')

print('<------------------------------------------Frequency of words in webpage -----------------------------------------------> n')

print(webpage_count)