Предварительная обработка текста в НЛП с помощью Python

Обработка естественного языка (Natural Language Processing, NLP) – это область искусственного интеллекта (ИИ) и вычислительной лингвистики, направленная на создание условий для понимания, интерпретации и генерирования человеческого языка компьютерами. Она включает в себя взаимодействие между компьютерами и естественным языком, позволяя машинам обрабатывать, анализировать и реагировать на текстовые или речевые данные таким образом, чтобы они были осмысленными и полезными для человека.

Важные терминологии

Ниже приведены некоторые из важных терминологий, используемых в НЛП:

• Документ: В НЛП под документом понимается отдельная единица текста, часто представленная в виде абзаца, предложения или даже одного слова. Он является основным структурным элементом текстовых данных в задачах НЛП. Например, в наборе данных, содержащем отзывы покупателей, каждый отдельный отзыв считается документом.
• Корпус (Corpus): Корпус – это коллекция документов, собранная для обучения или анализа языковой модели. Он служит репрезентативной выборкой изучаемого языка или области. Например, корпус для анализа настроений может состоять из тысяч отзывов покупателей, собранных из различных источников.
• Словарный запас: Под словарным запасом корпуса понимается набор уникальных слов, присутствующих во всей коллекции документов. По сути, он представляет собой слова, которые используются в определенном контексте. Например, словарь корпуса медицинских статей может включать такие слова, как “болезнь”, “лечение” и “симптомы”.
• Сегментация: Сегментация – это процесс разбиения блока текста (например, абзаца) на отдельные предложения. Правильная сегментация очень важна для решения различных задач НЛП, таких как машинный перевод или анализ настроения. Например, рассмотрим текст: “Я люблю НЛП. Это увлекательно”. Сегментация разделит его на два предложения: “Я люблю НЛП” и “Это увлекательно”.
• Стоп-слова: Стоп-слова – это обычные слова, которые часто встречаются в языке и не несут существенной смысловой нагрузки или информации для задач НЛП. Они часто удаляются в процессе предварительной обработки для уменьшения шума и повышения эффективности вычислений. Примерами стоп-слов в английском языке являются “the”, “and”, “is” и т.д.
• Стемминг: Стемминг – это метод сокращения слов до их базовой или корневой формы путем удаления суффиксов. Цель состоит в том, чтобы упростить слова так, чтобы варианты одного и того же корневого слова рассматривались как одинаковые. Однако не всегда в результате стемминга получаются осмысленные или правильные слова. Например, слова “бег” и “бежит” после удаления суффиксов преобразуются в слово “бег”.
• Лемматизация: Лемматизация похожа на стебли, но идет дальше, сокращая слова до их базовой или словарной формы (леммы). Этот процесс гарантирует, что полученные слова имеют правильное значение. Например, после лемматизации слова “run” и “runs” будут преобразованы в слово “run”.
• Метки NER: Распознавание именованных сущностей (NER) – это процесс идентификации и классификации конкретных сущностей, таких как имена людей, названия мест, организаций, даты и т.д., в тексте. Эти сущности часто помечаются соответствующими метками, такими как “человек”, “место”, “организация” и т.д. Например, в предложении “Штаб-квартира Apple Inc. находится в Купертино” метка NER обозначает “Apple Inc.” как организацию, а “Купертино” как местоположение.
• POS-тегирование: Метки части речи (POS) – это процесс присвоения грамматических меток каждому слову в предложении, указывающих на его синтаксическую роль и категорию, например, существительное, глагол, прилагательное и т.д. Например, в предложении “She eats an apple” с помощью POS-тегов можно обозначить “She” как местоимение, “eats” как глагол, а “apple” как существительное.
• Распределение по частям: Куски – это объединение соседних слов в предложении в значимые единицы, такие как фразы с существительными или фразы с глаголами. Эти фрагменты представляют собой синтаксические единицы, которые могут помочь в дальнейшем анализе или понимании структуры предложения. Например, в предложении “The big cat sat on the mat” (Большая кошка сидела на коврике) с помощью группировки можно выделить “The big cat” как существительное, а “sat on the mat” как глагольное словосочетание.

Предварительная обработка текста

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

Понижение регистра – это процесс преобразования всего текста в нижний регистр. Это распространенный этап предварительной обработки в НЛП, позволяющий обеспечить единообразие и избежать проблем, связанных с чувствительностью к регистру. Реализация процесса приведения текста к нижнему регистру в Python выглядит следующим образом:

def lowercase_text(text):
    return text.lower()

# Test the function
input_text = "The Quick Brown Fox JUMPS Over 2 Lazy Dogs."
output_text = lowercase_text(input_text)
print(output_text)

В приведенном выше коде функция lowercase_text() принимает входной текст и преобразует его в нижний регистр с помощью метода lower(), доступного в Python для строк. Перевод текста в нижний регистр полезен тем, что позволяет стандартизировать текстовые данные и рассматривать различные формы одного и того же слова как одинаковые. Например, слова “Hello”, “hello” и “HELLO” после понижения регистра будут преобразованы в “hello”. Это необходимо для нормализации текста и повышения точности моделей НЛП за счет уменьшения объема словарного запаса и нечувствительности слов к регистру.

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

import string

def remove_punctuations(text):
    translator = str.maketrans('', '', string.punctuation)
    return text.translate(translator)

# Test the function
input_text = "Hello, my name is John! How are you?"
output_text = remove_punctuations(input_text)
print(output_text)

В приведенном выше коде для удаления всех знаков препинания из входного текста используется функция remove_punctuations(). Функция использует константу string.punctuation из модуля string для получения строки, содержащей все знаки препинания. Затем она создает таблицу трансляции с помощью str.maketrans() и удаляет из входного текста все символы из таблицы знаков препинания с помощью метода translate().

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

import re

def remove_special_characters_numbers(text):
    # Regular expression to remove non-alphabetic characters and numbers
    return re.sub(r'[^a-zA-Z\s]', '', text)

# Test the function
input_text = "Hello, my name is Saif Ali and my age is 25! I was born on 1997-01-10."
output_text = remove_special_characters_numbers(input_text)
print(output_text)

В приведенном выше коде мы используем функцию remove_special_characters_numbers() для удаления из входного текста всех специальных символов и цифр. Функция использует метод re.sub() из модуля re (regular expression) с регулярным выражением r'[^a-zA-Z\s]’ для поиска любого символа, который не является прописным или строчным алфавитом или пробелом. Затем он заменяет эти символы пустой строкой, фактически удаляя их из текста.

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

import re

def remove_html_tags(text):
    clean_text = re.sub(r'<.*?>', '', text)
    return clean_text

# Test the function
input_text = "<p>Hello, <b>my name</b> is <i>John</i>!</p>"
output_text = remove_html_tags(input_text)
print(output_text)

В приведенном выше коде функция remove_html_tags() использует регулярные выражения (re.sub()) для удаления всех HTML-тегов из входного текста. Регулярное выражение r'<.?>’ соответствует любому шаблону, который начинается с ‘<‘, затем следуют любые символы (‘.‘) и заканчивается ‘>’. Это позволяет удалить все HTML-теги и оставить только текстовое содержимое.

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

import re

def remove_urls(text):
    clean_text = re.sub(r'http\S+|www\S+', '', text)
    return clean_text

# Test the function
input_text = "Check out my LinkedIn account: https://www.linkedin.com/in/imsaifali/"
output_text = remove_urls(input_text)
print(output_text)

В приведенном выше коде функция remove_urls() использует регулярные выражения (re.sub()) для удаления любых URL из входного текста. Регулярное выражение r’http\S+|www\S+’ соответствует любому URL, начинающемуся с “http://” или “https://” (за http следуют символы без пробелов \S+), или URL, начинающемуся с “www.”. (www с последующими символами без пробелов \S+). В результате все URL-адреса будут удалены из текста.

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

import re

def remove_extra_spaces(text):
    clean_text = re.sub(r'\s+', ' ', text)
    return clean_text.strip()

# Test the function
input_text = "Hello    there,     how    are   you?"
output_text = remove_extra_spaces(input_text)
print(output_text)

В приведенном выше коде функция remove_extra_spaces() с помощью регулярных выражений (re.sub()) удаляет любые последовательности из одного или нескольких пробельных символов (пробелы, табуляции, новые строки) и заменяет их одним пробелом. Регулярное выражение r’\s+’ соответствует одному или нескольким пробельным символам. Затем с помощью метода strip() удаляются все лидирующие и отстающие пробелы.

Расширение сокращений – это процесс преобразования сокращенных форм слов (например, “не”, “нельзя”) в их полные формы (например, “не”, “нельзя”). Этот шаг полезен для стандартизации текста и предотвращения возможной двусмысленности в задачах НЛП.

contraction_mapping = {
    "ain't": "is not",
    "aren't": "are not",
    "can't": "cannot",
    "couldn't": "could not",
    "didn't": "did not",
    "doesn't": "does not",
    "don't": "do not",
    "hadn't": "had not",
    "hasn't": "has not",
    "haven't": "have not",
    "he's": "he is",
    "he'll": "he will",
    "he'd": "he would",
    "i've": "I have",
    "i'll": "I will",
    "i'd": "I would",
    "i'm": "I am",
    "isn't": "is not",
    "it's": "it is",
    "it'll": "it will",
    "it'd": "it would",
    "let's": "let us",
    "mightn't": "might not",
    "mustn't": "must not",
    "shan't": "shall not",
    "she's": "she is",
    "she'll": "she will",
    "she'd": "she would",
    "shouldn't": "should not",
    "that's": "that is",
    "there's": "there is",
    "they're": "they are",
    "they've": "they have",
    "they'll": "they will",
    "they'd": "they would",
    "we're": "we are",
    "we've": "we have",
    "we'll": "we will",
    "we'd": "we would",
    "weren't": "were not",
    "what's": "what is",
    "won't": "will not",
    "wouldn't": "would not",
    "you're": "you are",
    "you've": "you have",
    "you'll": "you will",
    "you'd": "you would",
    "isn't": "is not",
    "it's": "it is",
    "that's": "that is",
    "there's": "there is",
    "here's": "here is",
    "who's": "who is",
    "what's": "what is",
    "where's": "where is",
    "when's": "when is",
    "why's": "why is",
    "how's": "how is",
}

def expand_contractions(text):
    words = text.split()
    expanded_words = [contraction_mapping[word.lower()] if word.lower() in contraction_mapping else word for word in words]
    return ' '.join(expanded_words)

# Test the function
input_text = "I can't believe it's already Friday!"
output_text = expand_contractions(input_text)
print(output_text)

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

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

Для коррекции текста мы будем использовать библиотеку TextBlob, которая предоставляет удобный интерфейс для таких задач обработки текста, как проверка и коррекция орфографии. Убедитесь, что у вас установлены библиотеки textblob и nltk. Если нет, установите их с помощью:

pip install textblob nltk

Теперь откорректируем текст:

from textblob import TextBlob

def correct_text(text):
    blob = TextBlob(text)
    corrected_text = blob.correct()
    return str(corrected_text)

# Test the function
input_text = "I am lerning NLP with Pyhton."
output_text = correct_text(input_text)
print(output_text)

В приведенном выше коде для коррекции входного текста используется функция correct_text(). Функция использует класс TextBlob из библиотеки textblob для создания объекта TextBlob из входного текста. Затем к объекту TextBlob применяется метод correct(), который автоматически выполняет коррекцию орфографии и другие исправления текста.

Токенизация – это процесс разбиения текста на отдельные слова или лексемы. Это важный этап предварительной обработки в НЛП, который подготавливает текст к дальнейшему анализу. Мы будем использовать библиотеку nltk, которая предоставляет различные методы токенизации. Убедитесь, что у вас установлена библиотека nltk. Если нет, установите ее с помощью:

pip install nltk

Теперь выполним токенизацию:

import nltk
nltk.download('punkt')
from nltk.tokenize import word_tokenize

def tokenize_text(text):
    return word_tokenize(text)

# Test the function
input_text = "The quick brown fox jumps over the lazy dog."
output_tokens = tokenize_text(input_text)
print(output_tokens)

В приведенном выше коде для токенизации входного текста используется функция tokenize_text(). Функция использует метод word_tokenize() из модуля nltk.tokenize для разбиения текста на отдельные слова (лексемы).

Удаление стоп-слов – это этап предварительной обработки текста, на котором из него удаляются обычные слова, не имеющие практически никакого смыслового значения, так называемые стоп-слова, чтобы уменьшить шум и сосредоточиться на более значимых словах. Для удаления стоп-слов мы будем использовать библиотеку nltk, которая предоставляет список распространенных стоп-слов для различных языков. Убедитесь, что у вас установлена библиотека nltk. Если нет, установите ее с помощью:

pip install nltk

Теперь выполним удаление стоп-слов:

import nltk
nltk.download('punkt')
nltk.download('stopwords')
from nltk.corpus import stopwords
stop_words = set(stopwords.words('english'))

def remove_stopwords(text):
    words = text.split()
    filtered_words = [word for word in words if word.lower() not in stop_words]
    return ' '.join(filtered_words)

# Test the function
input_text = "The quick brown fox jumps over the lazy dog."
output_text = remove_stopwords(input_text)
print(output_text)

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

Стемминг – это метод предварительной обработки текста, целью которого является сокращение слов до их базовой или корневой формы путем удаления суффиксов. Этот процесс позволяет уменьшить объем словарного запаса и рассматривать различные формы одного и того же слова как одинаковые. Для стемминга мы будем использовать библиотеку nltk, которая предоставляет различные стеммеры, включая Porter Stemmer. Убедитесь, что у вас установлена библиотека nltk. Если нет, установите ее, используя:

pip install nltk

Теперь выполним стеблирование:

import nltk
nltk.download('punkt')
from nltk.stem import PorterStemmer

def perform_stemming(text):
    stemmer = PorterStemmer()
    words = text.split()
    stemmed_words = [stemmer.stem(word) for word in words]
    return ' '.join(stemmed_words)

# Test the function
input_text = "jumps jumping jumped"
output_text = perform_stemming(input_text)
print(output_text)

В приведенном выше коде мы используем функцию perform_stemming() для применения стемминга к входному тексту. Эта функция использует PorterStemmer из модуля nltk.stem, который является широко распространенным алгоритмом стемминга. Он разбивает входной текст на отдельные слова, применяет к каждому слову стебли, а затем объединяет стебли в одну строку.

Лемматизация – это метод предварительной обработки текста, при котором слова сводятся к их базовой или корневой форме (лемме) с помощью словарного и морфологического анализа. В отличие от стемминга, лемматизация гарантирует, что полученное слово является правильным словом в данном языке. Для лемматизации мы будем использовать библиотеку nltk, которая предоставляет лемматизатор WordNet. Убедитесь, что у вас установлена библиотека nltk. Если нет, установите ее, используя:

pip install nltk

Теперь выполним лемматизацию:

import nltk
nltk.download('punkt')
nltk.download('wordnet')
from nltk.stem import WordNetLemmatizer

def perform_lemmatization(text):
    lemmatizer = WordNetLemmatizer()
    words = text.split()
    lemmatized_words = [lemmatizer.lemmatize(word) for word in words]
    return ' '.join(lemmatized_words)

# Test the function
input_text = "jumps jumping jumped"
output_text = perform_lemmatization(input_text)
print(output_text)

В приведенном выше коде мы используем функцию perform_lemmatization() для применения лемматизации к входному тексту. Функция использует WordNetLemmatizer из модуля nltk.stem, который основан на лексической базе данных WordNet. Она разбивает входной текст на отдельные слова, применяет к каждому слову лемматизацию, а затем объединяет лемматизированные слова в единую строку.

Заключение

Препроцессинг текста – важнейший этап обработки естественного языка (NLP), который заключается в преобразовании исходных текстовых данных в чистый и нормализованный формат, пригодный для анализа и моделирования. К числу основных методов обработки текста относятся выделение строчных букв, токенизация, удаление специальных символов и цифр, удаление стоп-слов, стемминг, лемматизация, удаление HTML-тегов, удаление URL-адресов, расширение сокращений и коррекция текста с помощью таких инструментов, как TextBlob.

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