Овладяване на класификацията на текст с NLP: Най-доброто ръководство за откриване на спам, анализ на настроението...

От Daniel Eniayeju

В днешния дигитален свят текстовите данни са навсякъде. От имейли до публикации в социални медии, от рецензии на клиенти до новинарски статии, фирмите и хората са залети с огромно количество текстова информация. Способността за ефективно класифициране и анализиране на тези данни е от решаващо значение за вземане на информирани решения и получаване на ценна информация. Тук се намесва обработката на естествен език (NLP). NLP е клон на изкуствения интелект, който позволява на компютрите да разбират човешкия език и да интерпретират значението му. В това най-добро ръководство ще проучим как NLP алгоритмите могат да се използват за класифициране на текстови данни за откриване на спам, анализ на настроението и категоризиране на теми. Ще се потопим в техническите детайли на различни НЛП техники и ще предоставим практически примери как да ги приложим. Независимо дали сте учен по данни, търговец или просто сте любопитни за НЛП, това ръководство ще ви предостави знанията и уменията да овладеете класификацията на текст с НЛП.

Откриване на спам

Откриването на спам има за цел да идентифицира непоискани или нежелани имейли, съобщения или съдържание. Няколко подхода и алгоритми са ефективни при справянето с този проблем:

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

Практически сценарий за класификация, базирана на правила

Първо, ние определяме правилата

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

Кодов фрагмент за прилагане на базиран на правила класификатор. Това може да стане с помощта на регулярни изрази, съвпадение на низове или други подходящи техники.

import re

def classify_message(message):
    # Rule 1: Check for specific keywords in the subject line
    keywords = ['free', 'urgent', 'limited time offer']
    if any(keyword in message['subject'] for keyword in keywords):
        return 'spam'

    # Rule 2: Check for suspicious email addresses
    if re.match(r'.*@spamdomain\.com$', message['from']):
        return 'spam'

    # Rule 3: Check for excessive use of capital letters and symbols
    if re.search(r'[A-Z]{4,}|\$\$|\!\!', message['body']):
        return 'spam'

    # If none of the rules apply, classify as non-spam
    return 'non-spam'

# Usage example
message = {
    'subject': 'Congratulations! You have won a free prize!',
    'from': '[email protected]',
    'body': 'Get ready for the amazing offer!! Act now!'
}

classification = classify_message(message)
print(classification)  # Output: 'spam'

Този кодов фрагмент започва с импортиране на необходимите модули. В този случай ние импортираме модула за регулярни изрази (re).

След това се дефинира функция, наречена classify_message. Тази функция приема съобщение като вход и прилага дефинираните правила, за да го класифицира като спам или не-спам.

Правило 1: Функцията проверява дали някоя от предварително дефинираните ключови думи (напр. безплатно, спешно, ограничено време) присъства в реда за тема на съобщението. Ако някоя от ключовите думи бъде открита, функцията незабавно класифицира съобщението като спам.

Правило 2: Функцията използва модел на регулярен израз, за да провери дали имейл адресът на изпращача съвпада с модела *@spamdomain.com. Ако го направи, функцията класифицира съобщението като спам.

Правило 3: Друг модел на регулярен израз се използва за търсене на прекомерна употреба на главни букви (4 или повече последователни главни букви) или специфични символи като $$ или !! в тялото на съобщението. Ако някой от тези модели бъде открит, функцията класифицира съобщението като спам.

Ако нито едно от дефинираните правила не важи за съобщението, то се класифицира като неспам.

Накрая се създава примерен речник на съобщение с примерни стойности за темата, подателя и тялото на съобщението.

Функцията classify_message се извиква с примерното съобщение като вход и получената класификация (спам или неспам) се отпечатва.

2. Алгоритми за машинно обучение: a. Наивен Бейс: Наивните Бейс класификатори са вероятностни модели, които използват теоремата на Бейс. Те приемат независимост между характеристиките и изчисляват вероятността даден документ да принадлежи към определен клас.

В контекста на откриването на нежелана поща, Naive Bayes класификаторите оценяват вероятността даден документ да бъде спам или да не е спам въз основа на наличието или отсъствието на определени думи или характеристики.

Ето кодов фрагмент, който демонстрира как да тренирате и използвате Naive Bayes класификатор за откриване на нежелана поща с помощта на библиотеката scikit-learn в Python:

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

# Example data
messages = [
    ("Congratulations! You've won a free trip to Hawaii.", "spam"),
    ("Get rich quick! Earn $10,000 in just one week.", "spam"),
    ("Hi there, how are you doing? Let's meet up for coffee.", "non-spam"),
    ("URGENT: Your account has been compromised. Please reset your password.", "spam"),
    ("Reminder: Your appointment is tomorrow at 2 PM.", "non-spam"),
    # ... add more labeled messages
]

# Split messages into features (text) and labels
texts, labels = zip(*messages)

# Split data into training and testing sets
text_train, text_test, label_train, label_test = train_test_split(texts, labels, test_size=0.2, random_state=42)

# Create a CountVectorizer to convert text to numeric features
vectorizer = CountVectorizer()

# Transform training and testing texts into feature vectors
features_train = vectorizer.fit_transform(text_train)
features_test = vectorizer.transform(text_test)

# Train a Naive Bayes classifier
classifier = MultinomialNB()
classifier.fit(features_train, label_train)

# Predict labels for the test set
predictions = classifier.predict(features_test)

# Calculate accuracy
accuracy = accuracy_score(label_test, predictions)
print("Accuracy:", accuracy)

В този кодов фрагмент:

Примерните данни се състоят от списък от съобщения, като всяко е съчетано със съответния етикет, указващ дали е спам или не е спам.

Съобщенията са разделени на текстове (съдържание на съобщението) и етикети (спам или неспам).

След това данните се разделят на комплекти за обучение и тестване с помощта на функцията train_test_split от scikit-learn.

CountVectorizer се използва за преобразуване на текстовите данни в числово представяне чрез създаване на матрица от брой думи.

Текстовете за обучение се трансформират във вектори на характеристики с помощта на vectorizer.fit_transform(text_train), а текстовете за тестване се трансформират с помощта на vectorizer.transform(text_test).

Класификаторът MultinomialNB се инициализира и обучава на функциите за обучение и етикетите с помощта на classifier.fit(features_train, label_train).

Класификаторът се използва за предсказване на етикети за тестовите характеристики с помощта на classifier.predict(features_test).

И накрая, точността на класификатора се изчислява чрез сравняване на предвидените етикети с действителните етикети с помощта на функцията accuracy_score.

б. Поддържащи векторни машини: (SVM) са мощни модели за контролирано обучение, използвани за задачи за класифициране. SVM имат за цел да намерят оптимална хиперравнина, която разделя точките от данни от различни класове с максимален марж. В контекста на откриването на нежелана поща, SVM могат да бъдат обучени на цифрови вектори на характеристики, представляващи текстови документи, за да класифицират ефективно спам и неспам съобщения.

Ето кодов фрагмент, който демонстрира как да обучавате и използвате SVM класификатор за откриване на спам с помощта на библиотеката scikit-learn в Python:

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Example data
messages = [
    ("Congratulations! You've won a free trip to Hawaii.", "spam"),
    ("Get rich quick! Earn $10,000 in just one week.", "spam"),
    ("Hi there, how are you doing? Let's meet up for coffee.", "non-spam"),
    ("URGENT: Your account has been compromised. Please reset your password.", "spam"),
    ("Reminder: Your appointment is tomorrow at 2 PM.", "non-spam"),
    # ... add more labeled messages
]

# Split messages into features (text) and labels
texts, labels = zip(*messages)

# Split data into training and testing sets
text_train, text_test, label_train, label_test = train_test_split(texts, labels, test_size=0.2, random_state=42)

# Create a TfidfVectorizer to convert text to numerical features
vectorizer = TfidfVectorizer()

# Transform training and testing texts into feature vectors
features_train = vectorizer.fit_transform(text_train)
features_test = vectorizer.transform(text_test)

# Train an SVM classifier
classifier = SVC()
classifier.fit(features_train, label_train)

# Predict labels for the test set
predictions = classifier.predict(features_test)

# Calculate accuracy
accuracy = accuracy_score(label_test, predictions)
print("Accuracy:", accuracy)

В този кодов фрагмент:

Съобщенията са разделени на текстове (съдържание на съобщението) и етикети (спам или неспам).

След това данните се разделят на комплекти за обучение и тестване с помощта на функцията train_test_split от scikit-learn.

TfidfVectorizer се използва за преобразуване на текстовите данни в числено представяне чрез изчисляване на стойностите на честотата на термина-обратна честота на документа (TF-IDF).

SVM класификатор (SVC) се инициализира и обучава на функциите за обучение и етикетите с помощта на classifier.fit(features_train, label_train).

в. Случайни гори:

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

Ето кодов фрагмент, който демонстрира как да обучавате и използвате класификатор Random Forest за откриване на нежелана поща с помощта на библиотеката scikit-learn в Python:

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Example data
messages = [
    ("Congratulations! You've won a free trip to Hawaii.", "spam"),
    ("Get rich quick! Earn $10,000 in just one week.", "spam"),
    ("Hi there, how are you doing? Let's meet up for coffee.", "non-spam"),
    ("URGENT: Your account has been compromised. Please reset your password.", "spam"),
    ("Reminder: Your appointment is tomorrow at 2 PM.", "non-spam"),
    # ... add more labeled messages
]

# Split messages into features (text) and labels
texts, labels = zip(*messages)

# Split data into training and testing sets
text_train, text_test, label_train, label_test = train_test_split(texts, labels, test_size=0.2, random_state=42)

# Create a TfidfVectorizer to convert text to numerical features
vectorizer = TfidfVectorizer()

# Transform training and testing texts into feature vectors
features_train = vectorizer.fit_transform(text_train)
features_test = vectorizer.transform(text_test)

# Train a Random Forest classifier
classifier = RandomForestClassifier()
classifier.fit(features_train, label_train)

# Predict labels for the test set
predictions = classifier.predict(features_test)

# Calculate accuracy
accuracy = accuracy_score(label_test, predictions)
print("Accuracy:", accuracy)

В този кодов фрагмент:

Съобщенията са разделени на текстове (съдържание на съобщението) и етикети (спам или неспам).

След това данните се разделят на комплекти за обучение и тестване с помощта на функцията train_test_split от scikit-learn.

Класификатор на произволна гора (RandomForestClassifier) се инициализира и обучава на функциите за обучение и етикетите с помощта на classifier.fit(features_train, label_train).

Класификация на чувствата

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

Подходи в класификацията на чувствата

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

Ето кодов фрагмент, който демонстрира прост подход, базиран на лексикон, за класифициране на настроения, използвайки лексикона AFINN-111 в Python:

from afinn import Afinn

# Initialize the AFINN-111 sentiment lexicon
afinn = Afinn()

# Example texts
texts = [
    "I love this product! It works amazingly well.",
    "This movie is terrible. I hated every minute of it.",
    "The weather today is neither good nor bad.",
    "I feel indifferent about this book.",
    # ... add more texts
]

# Perform sentiment classification
for text in texts:
    sentiment_score = afinn.score(text)
    if sentiment_score > 0:
        sentiment = "Positive"
    elif sentiment_score < 0:
        sentiment = "Negative"
    else:
        sentiment = "Neutral"
    print("Text:", text)
    print("Sentiment:", sentiment)
    print("Sentiment Score:", sentiment_score)
    print()

В този кодов фрагмент:

Обектът afinn се инициализира с лексикона за чувства AFINN-111. Лексиконът AFINN-111 съдържа списък с предварително изчислени оценки на настроението за думи на английски език, където положителните резултати показват положително настроение, а отрицателните резултати показват отрицателно настроение.

Предоставени са примерни текстове, представящи различни настроения: положителни, отрицателни и неутрални.

Класификацията на настроението се извършва чрез изчисляване на оценката на настроението на всеки текст с помощта на afinn.score(text). Резултатът за настроение е сумата от оценките за настроение на отделните думи в текста.

Въз основа на оценката на настроението, настроението на текста се определя като положително (ако резултатът е по-голям от 0), отрицателен (ако резултатът е по-малък от 0) или неутрален (ако резултатът е 0).

Настроенията, оценката на настроението и оригиналният текст се отпечатват за всеки пример.

2. Техники за машинно обучение:

а. Логистична регресия:

Логистичната регресия е популярен линеен модел, използван за задачи за двоична класификация, включително класификация на настроението. Той прогнозира вероятността документът да принадлежи към определен клас настроения, като положителен или отрицателен. Логистичната регресия може да се справи с големи пространства от функции и се представя добре при задачи за класификация на настроенията.

Ето кодов фрагмент, който демонстрира как да обучавате и използвате модел на логистична регресия за класификация на настроения, като използвате библиотеката scikit-learn в Python:

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Example data
texts = [
    "I love this product! It works amazingly well.",
    "This movie is terrible. I hated every minute of it.",
    "The weather today is neither good nor bad.",
    "I feel indifferent about this book.",
    # ... add more texts
]

labels = ["positive", "negative", "neutral", "neutral", ...]  # Corresponding labels for each text

# Split data into training and testing sets
text_train, text_test, label_train, label_test = train_test_split(texts, labels, test_size=0.2, random_state=42)

# Create a TfidfVectorizer to convert text to numerical features
vectorizer = TfidfVectorizer()

# Transform training and testing texts into feature vectors
features_train = vectorizer.fit_transform(text_train)
features_test = vectorizer.transform(text_test)

# Train a Logistic Regression model
classifier = LogisticRegression()
classifier.fit(features_train, label_train)

# Predict labels for the test set
predictions = classifier.predict(features_test)

# Calculate accuracy
accuracy = accuracy_score(label_test, predictions)
print("Accuracy:", accuracy)

В този кодов фрагмент:

Примерните данни се състоят от списък с текстове и съответните им етикети, указващи класа на настроение (напр. положителен, отрицателен, неутрален).

Данните се разделят на комплекти за обучение и тестване с помощта на функцията train_test_split от scikit-learn.

Логистичен регресионен модел (LogisticRegression) се инициализира и обучава върху характеристиките и етикетите за обучение с помощта на classifier.fit(features_train, label_train).

б. Повтарящи се невронни мрежи (RNN):

Повтарящите се невронни мрежи (RNN) са клас невронни мрежи, които са много подходящи за моделиране на последователни данни, като например текст. Те имат способността да улавят зависимостите между думите и ефективно да моделират последователния характер на изреченията. Варианти на RNN, като Long Short-Term Memory (LSTM) и Gated Recurrent Unit (GRU), адресират проблема с изчезващия градиент и позволяват по-добро запазване на дългосрочни зависимости в текста. Вариантите LSTM и GRU са особено ефективни при задачи за класификация на настроенията поради способността им да улавят контекстуална информация.

Ето един кодов фрагмент, който демонстрира как да обучавате и използвате базиран на LSTM модел за класифициране на настроения с помощта на библиотеката Keras в Python:

from keras.models import Sequential
from keras.layers import Embedding, LSTM, Dense
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Example data
texts = [
    "I love this product! It works amazingly well.",
    "This movie is terrible. I hated every minute of it.",
    "The weather today is neither good nor bad.",
    "I feel indifferent about this book.",
    # ... add more texts
]

labels = ["positive", "negative", "neutral", "neutral", ...]  # Corresponding labels for each text

# Split data into training and testing sets
text_train, text_test, label_train, label_test = train_test_split(texts, labels, test_size=0.2, random_state=42)

# Tokenize and pad the text sequences
tokenizer = Tokenizer()
tokenizer.fit_on_texts(text_train)
sequences_train = tokenizer.texts_to_sequences(text_train)
sequences_test = tokenizer.texts_to_sequences(text_test)
vocab_size = len(tokenizer.word_index) + 1
max_seq_length = max(len(sequence) for sequence in sequences_train)
X_train = pad_sequences(sequences_train, maxlen=max_seq_length)
X_test = pad_sequences(sequences_test, maxlen=max_seq_length)

# Create an LSTM model
model = Sequential()
model.add(Embedding(vocab_size, 100, input_length=max_seq_length))
model.add(LSTM(128))
model.add(Dense(1, activation='sigmoid'))

# Compile the model
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Train the model
model.fit(X_train, label_train, batch_size=64, epochs=10, validation_data=(X_test, label_test))

# Predict labels for the test set
predictions = model.predict_classes(X_test)

# Calculate accuracy
accuracy = accuracy_score(label_test, predictions)
print("Accuracy:", accuracy)

В този кодов фрагмент:

Данните се разделят на комплекти за обучение и тестване с помощта на функцията train_test_split от scikit-learn.

Текстовете се токенизират с помощта на класа Tokenizer от Keras, който присвоява уникален целочислен индекс на всяка дума в речника.

След това токенизираните текстови последователности се допълват, за да имат еднаква дължина с помощта на pad_sequences, за да се осигурят еднакви входни размери за модела LSTM.

Базиран на LSTM модел се дефинира с помощта на Keras Sequential API. Моделът се състои от слой за вграждане, слой LSTM и плътен слой със сигмоидно активиране за двоична класификация.

Моделът е компилиран с оптимизатора на Адам и двоичната функция за загуба на кръстосана ентропия.

Моделът се обучава върху данните за обучение с помощта на model.fit.

Прогнозите се правят върху тестовите данни с помощта на model.predict_classes.

Точността на модела се изчислява чрез сравняване на предвидените етикети с действителните етикети с помощта на функцията accuracy_score от scikit-learn.

GRU (Gated Recurrent Unit) е друг вариант на повтарящи се невронни мрежи (RNN), който адресира проблема с изчезващия градиент и предоставя по-ефективен начин за улавяне на последователна информация в текст. GRU опростява архитектурата на традиционните RNN, като комбинира паметта и скритото състояние, което води до по-малко параметри и по-бързо обучение. Той показа обещаващо представяне при различни задачи за обработка на естествен език, включително класификация на чувствата.

Ето един кодов фрагмент, който демонстрира как да обучавате и използвате базиран на GRU модел за класификация на настроенията с помощта на библиотеката Keras в Python:

from keras.models import Sequential
from keras.layers import Embedding, GRU, Dense
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Example data
texts = [
    "I love this product! It works amazingly well.",
    "This movie is terrible. I hated every minute of it.",
    "The weather today is neither good nor bad.",
    "I feel indifferent about this book.",
    # ... add more texts
]

labels = ["positive", "negative", "neutral", "neutral", ...]  # Corresponding labels for each text

# Split data into training and testing sets
text_train, text_test, label_train, label_test = train_test_split(texts, labels, test_size=0.2, random_state=42)

# Tokenize and pad the text sequences
tokenizer = Tokenizer()
tokenizer.fit_on_texts(text_train)
sequences_train = tokenizer.texts_to_sequences(text_train)
sequences_test = tokenizer.texts_to_sequences(text_test)
vocab_size = len(tokenizer.word_index) + 1
max_seq_length = max(len(sequence) for sequence in sequences_train)
X_train = pad_sequences(sequences_train, maxlen=max_seq_length)
X_test = pad_sequences(sequences_test, maxlen=max_seq_length)

# Create a GRU model
model = Sequential()
model.add(Embedding(vocab_size, 100, input_length=max_seq_length))
model.add(GRU(128))
model.add(Dense(1, activation='sigmoid'))

# Compile the model
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Train the model
model.fit(X_train, label_train, batch_size=64, epochs=10, validation_data=(X_test, label_test))

# Predict labels for the test set
predictions = model.predict_classes(X_test)

# Calculate accuracy
accuracy = accuracy_score(label_test, predictions)
print("Accuracy:", accuracy)

В този кодов фрагмент единствената разлика от примера за LSTM е използването на GRUlayer вместо слоя LSTM. Останалата част от кода остава същата. Моделите, базирани на GRU, предлагат подобни предимства на моделите LSTM при улавяне на последователна информация, но с по-проста архитектура и потенциално по-бързо обучение.

в. Трансформърс:а

BERT (Bidirectional Encoder Representations from Transformers) е модерен модел, базиран на трансформатор, който постигна забележителен успех в различни NLP задачи. Моделите BERT улавят контекстуалната информация на думите по двупосочен начин, което им позволява да разберат значението и чувството на дума в контекста на цялото изречение.

Ето кодов фрагмент, който демонстрира как да използвате предварително обучения BERT модел от библиотеката Hugging Face Transformers за класификация на настроенията с помощта на библиотеката PyTorch в Python:

import torch
from transformers import BertTokenizer, BertForSequenceClassification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Example data
texts = [
    "I love this product! It works amazingly well.",
    "This movie is terrible. I hated every minute of it.",
    "The weather today is neither good nor bad.",
    "I feel indifferent about this book.",
    # ... add more texts
]

labels = ["positive", "negative", "neutral", "neutral", ...]  # Corresponding labels for each text

# Split data into training and testing sets
text_train, text_test, label_train, label_test = train_test_split(texts, labels, test_size=0.2, random_state=42)

# Load pre-trained BERT tokenizer and model
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=3)  # 3 for positive, negative, neutral

# Tokenize and encode the training texts
encoded_train = tokenizer.batch_encode_plus(
    text_train,
    add_special_tokens=True,
    padding='longest',
    truncation=True,
    return_tensors='pt'
)

# Tokenize and encode the testing texts
encoded_test = tokenizer.batch_encode_plus(
    text_test,
    add_special_tokens=True,
    padding='longest',
    truncation=True,
    return_tensors='pt'
)

# Extract input tensors
input_ids_train = encoded_train['input_ids']
attention_masks_train = encoded_train['attention_mask']
input_ids_test = encoded_test['input_ids']
attention_masks_test = encoded_test['attention_mask']
labels_train = torch.tensor(label_train)
labels_test = torch.tensor(label_test)

# Fine-tune the pre-trained BERT model
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-5)
model.train()
optimizer.zero_grad()

outputs = model(input_ids_train, attention_mask=attention_masks_train, labels=labels_train)
loss = outputs.loss
loss.backward()
optimizer.step()

# Evaluate the model on the testing set
model.eval()
with torch.no_grad():
    outputs = model(input_ids_test, attention_mask=attention_masks_test)
    logits = outputs.logits
    predicted_labels = torch.argmax(logits, dim=1).numpy()

# Calculate accuracy
accuracy = accuracy_score(label_test, predicted_labels)
print("Accuracy:", accuracy)

В този кодов фрагмент:

Данните се разделят на комплекти за обучение и тестване с помощта на функцията train_test_split от scikit-learn.

Токенизаторът на BERT и предварително обученият модел на BERT (BertTokenizer и BertForSequenceClassification) се зареждат от библиотеката Hugging Face Transformers.

Текстовете за обучение и тестване са токенизирани и кодирани с помощта на BERT tokenizer. Добавят се специални жетони и последователностите се допълват или съкращават до най-дългата дължина на последователността.

Входните тензори (input_ids и attention_masks) и тензорите на етикетите (етикетите) се извличат от кодираните последователности.

Предварително обученият BERT модел се настройва фино върху данните за обучение с помощта на извлечените входни тензори и етикети.

Моделът се оценява на базата на данните от тестването, като се правят прогнози за входните тензори и се изчисляват прогнозираните етикети.

Тематична категоризация

Категоризацията на теми, известна също като класификация на текст или класификация на документи, е задачата за присвояване на предварително дефинирани категории или теми на текстови документи. Целта е автоматично да се анализират и организират големи обеми текстови данни въз основа на тяхното съдържание.

Подходи в тематичната категоризация

Модел Bag-of-Words (BoW):

Моделът BoW представя документ като вектор от честоти на думите или индикатори за присъствие. Той третира всеки документ като неподредена колекция от думи и игнорира реда на думите. Общите стъпки, включени в използването на модела BoW за категоризиране на теми, са както следва:

Предварителна обработка на данни: Текстовите данни трябва да бъдат предварително обработени, за да се премахнат всички ненужни знаци, да се преобразува текстът в малки букви и да се справят с други задачи за предварителна обработка, като премахване на стоп думи, корен или лематизация.
Създаване на речник: Следващата стъпка е да създадете речник, който е списък от уникални думи, които се появяват в корпуса на документа. Всяка дума в речника служи като характеристика или измерение в представянето на BoW. Речникът обикновено се създава чрез сканиране на всички документи в набора за обучение и събиране на уникални думи.
Векторизация: След като речникът бъде създаден, всеки документ се трансформира във векторно представяне въз основа на присъстващите в него думи.

Има два често срещани начина за представяне на документите:

Честоти на думата: Всеки векторен елемент представлява честотата на дума в документа. Например, ако думата „котка“ се появи 3 пъти в документ, съответният векторен елемент за „котка“ ще има стойност 3.

Индикатори за присъствие: Всеки векторен елемент показва дали дадена дума присъства или отсъства в документа. Приема стойност 1, ако думата присъства, и 0 в противен случай. Процесът на векторизация води до матрица, в която всеки ред съответства на документ, а всяка колона съответства на дума в речника. Елементите на матрицата представляват честотите на думите или индикаторите за присъствие.

4. Обучение на класификатора: След като документите са представени като вектори, класификаторът за машинно обучение се обучава върху векторизираните данни за обучение. Популярните класификатори за категоризиране на теми включват Naive Bayes, Support Vector Machines (SVM), Decision Trees и Random Forests. Тези класификатори научават връзката между векторите на документа и съответните им категории

5. Предсказване на категории: След обучение на класификатора, той може да се използва за предвиждане на категориите на нови, невиждани документи. Новите документи се трансформират във векторни изображения, използвайки същия речник и техника за векторизация. След това обученият класификатор присвоява категория на всеки нов документ въз основа на неговото векторно представяне.

Ето кодов фрагмент, демонстриращ използването на модела Bag-of-Words за категоризиране на теми с помощта на библиотеката scikit-learn в Python:

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

# Example data
texts = [
    "This movie is great!",
    "I love this product!",
    "The weather is beautiful today.",
    "I'm not sure about this book.",
    # ... add more texts
]

labels = ["movie", "product", "weather", "book", ...]  # Corresponding labels for each text

# Split data into training and testing sets
text_train, text_test, label_train, label_test = train_test_split(texts, labels, test_size=0.2, random_state=42)

# Create a CountVectorizer
vectorizer = CountVectorizer()

# Fit the vectorizer on the training data and transform the texts into BoW vectors
X_train = vectorizer.fit_transform(text_train)
X_test = vectorizer.transform(text_test)

# Create a Naive Bayes classifier and train it on the training data
classifier = MultinomialNB()
classifier.fit(X_train, label_train)

# Make predictions on the test data
predictions = classifier.predict(X_test)

# Calculate accuracy
accuracy = accuracy_score(label_test, predictions)
print("Accuracy:", accuracy)

В този кодов фрагмент:

Примерните данни се състоят от списък с текстове и съответните им етикети.

Данните се разделят на комплекти за обучение и тестване с помощта на функцията train_test_split от scikit-learn.

CountVectorizer от scikit-learn се използва за трансформиране на текстовете в BoW вектори. Той токенизира текстовете, изгражда речника и брои срещанията на думи във всеки документ.

BoW векторите на данните за обучение и тестване се създават с помощта на методите fit_transform и transform на векторизатора, съответно.

Създава се мултиномиален наивен класификатор на Бейс и се обучава върху данните за обучение.

Прогнозите се правят върху данните от теста с помощта на обучен класификатор.

2. Вграждане на думи:

Вграждането на думи, като Word2Vec или GloVe, са плътни, нискоразмерни векторни представяния на думи, които улавят семантичните връзки между думите. Тези вграждания могат да се използват като функции за обучение на класификатори за извършване на категоризиране на теми. Ето примерен кодов фрагмент, демонстриращ използването на вграждане на думи за категоризиране на теми:

from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from gensim.models import Word2Vec
import numpy as np

# Example data
texts = [
    "This movie is great!",
    "I love this product!",
    "The weather is beautiful today.",
    "I'm not sure about this book.",
    # ... add more texts
]

labels = ["movie", "product", "weather", "book", ...]  # Corresponding labels for each text

# Split data into training and testing sets
text_train, text_test, label_train, label_test = train_test_split(texts, labels, test_size=0.2, random_state=42)

# Create word embeddings using Word2Vec
word2vec_model = Word2Vec(text_train, size=100, window=5, min_count=1, workers=4)

# Function to generate document vectors using word embeddings
def generate_doc_vector(text):
    vectors = []
    for word in text:
        if word in word2vec_model:
            vectors.append(word2vec_model[word])
    if vectors:
        return np.mean(vectors, axis=0)
    else:
        return np.zeros(100)  # Return zero vector if no word embeddings found for the text

# Generate document vectors for training data
X_train = np.array([generate_doc_vector(text.split()) for text in text_train])

# Generate document vectors for testing data
X_test = np.array([generate_doc_vector(text.split()) for text in text_test])

# Create a Support Vector Machine classifier and train it on the training data
classifier = SVC()
classifier.fit(X_train, label_train)

# Make predictions on the test data
predictions = classifier.predict(X_test)

# Calculate accuracy
accuracy = np.mean(predictions == label_test)
print("Accuracy:", accuracy)

В този кодов фрагмент:

Примерните данни се състоят от списък с текстове и съответните им етикети.

Данните се разделят на комплекти за обучение и тестване с помощта на функцията train_test_split от scikit-learn.

Моделът Word2Vec от библиотеката gensim се използва за генериране на вграждания на думи от данните за обучение.

Функцията generate_doc_vector е дефинирана за генериране на вектори на документи чрез вземане на средната стойност на вграждането на думи на думите, присъстващи във всеки текст. Ако дума не бъде намерена във вградените думи, се използва нулев вектор.

Векторите на документи се генерират за данните за обучение и тестване чрез прилагане на функцията generate_doc_vector.

Създава се класификатор на Support Vector Machine (SVM) и се обучава върху данните за обучение.

Прогнозите се правят върху данните от теста с помощта на обучен класификатор.

Точността на модела се изчислява чрез сравняване на предвидените етикети с действителните етикети.

3. Невронни мрежи: Дълбоките невронни мрежи, включително конволюционни невронни мрежи (CNN), повтарящи се невронни мрежи (RNN) и трансформатори, са показали голям успех в задачите за категоризиране на теми.

CNN могат да уловят локални модели в текста чрез прилагане на конволюционни операции върху последователности от думи или знаци. Те могат автоматично да научават важни функции и да се справят добре със задачи, при които местният контекст е от решаващо значение, като например класификация на текст.
RNN, особено варианти като Long Short-Term Memory (LSTM) и Gated Recurrent Unit (GRU), са ефективни при улавяне на последователна информация в текста. Те могат да моделират зависимости между думите и да дадат добри резултати при задачи за категоризиране на теми, където редът на думите е важен.
Трансформаторите, като модела BERT (Двупосочни енкодерни представяния от трансформатори), направиха революция в НЛП задачите. Transformers използват механизми за самовнимание, за да улавят ефективно контекстуална информация и са постигнали най-съвременни резултати в категоризирането на теми.

РЕЗЮМЕ

Тази статия е изчерпателно ръководство, обхващащо различни техники и алгоритми, използвани в НЛП за справяне с три критични задачи: откриване на спам, анализ на настроението и категоризиране на теми.

Тази статия разглежда трите основни задачи за класифициране на текст. Той изследва откриването на спам, като се фокусира върху идентифицирането и филтрирането на непоискани или злонамерени съобщения. Ние изследваме набор от подходи, включително класификация, базирана на правила, техники за машинно обучение като Naive Bayes, Support Vector Machines (SVM) и Random Forests

Следващата задача, която разгледахме, е класификацията на настроението, която има за цел да определи емоционалния тон зад текста. Тази статия обхваща различни методологии, включително базирани на лексикон подходи, традиционен алгоритъм за машинно обучение като логистична регресия и по-нови постижения като дългосрочна краткосрочна памет (LSTM), мрежи с рекурентна единица (GRU) и модел на трансформатор като BERT. Тези техники се оказаха ефективни при улавяне на контекстуална информация и извличане на настроение от текста.

И накрая, тази статия се занимава с категоризирането на теми, което включва класифициране на текст в предварително дефинирани категории или теми. Той обсъжда подходи като модела Bag of Words (BoW), в който обсъдихме общите стъпки, включени в използването на модела BoW. Вграждането на думи е друг подход, който обсъдихме, както и по-напреднали техники като невронни мрежи за дълбоко обучение като конволюционни невронни мрежи, повтарящи се невронни мрежи и трансформатори. Тези подходи позволяват точно класифициране на теми и извличане на значими прозрения от текстови данни.

В заключение, „Овладяване на текстова класификация с NLP: Най-доброто ръководство за откриване на спам, анализ на настроението и алгоритми за категоризиране на теми“ служи като изчерпателен ресурс за хора, които искат да разберат и прилагат техники за класифициране на текст. Той предоставя на читателите необходимите знания и практически умения за справяне с предизвикателствата при класификацията на текст в реалния свят, като използва силата на НЛП за извличане на ценни прозрения от текстови данни.

Вижте също:

Нови материали

Проверка на входа със Stenciljs

В този урок ще научите как да създавате хубави входове със Stencil като този по-долу. Ще научите също как да структурирате и предоставите библиотека от валидатори с вашата библиотека от уеб..

Пътят към кода

Защо е толкова трудно да напуснете зоната си на комфорт, за да следвате мечтите си на разработчици? Преди две години, около Коледа, реших да се отклоня от познатата си кариера и да започна..

Изкуственият интелект трансформира създаването на вкус — От данни към наслада

Създаването на вкус претърпява забележителна трансформация с интегрирането на техниките за изкуствен интелект (AI) и машинно обучение (ML). Чрез анализиране на огромно количество данни и..

Обработка на естествен език с Prolog

Обработката на естествен език (NLP) е решаващ аспект на изкуствения интелект, тъй като позволява на компютрите да разбират и интерпретират човешкия език. За да приложите възможностите на NLP в..

Работа с концепцията за обратна вероятност част 3 (машинно обучение)

Анализ на посредничество, базиран на обратно претегляне на вероятността за данни за микробиоми (arXiv) Автор : Yuexia Zhang , Jian Wang , Jiayi Shen , Jessica Galloway-Pena , Samuel..

Най-добри практики за управление на потребителски данни и удостоверяване в AngularJS приложения

AngularJS е популярна предна JavaScript рамка, която позволява на разработчиците да създават мощни и мащабируеми уеб приложения. Един от важните аспекти на изграждането на уеб приложения е..

Ресурси за машинно обучение

Ресурси от юли Какво пропуснахте през юли като инженер по машинно обучение... От общността 🙌 1.Skytowner Със SkyTowner вие кодирате 80% и четете 20% С висококачествените малки..

Етикети

Machine Learning JavaScript Data Science Artificial Intelligence Web Development Software Development Coding Python Deep Learning React AI Java Software Engineering Computer Science Nodejs Algorithms Typescript Programming Languages Productivity Development Computer Vision Data Reactjs Learning To Code NLP Front End Development Javascript Tips Mathematics Tech Statistics Neural Networks Towards Data Science Business Angular Tutorial ChatGPT Science Golang