Tekstclassificatie in Python begrijpen

Wat is tekstclassificatie?

Tekstclassificatie is een veelvoorkomende NLP-taak die wordt gebruikt om zakelijke problemen in diverse domeinen op te lossen. Het doel van tekstclassificatie is het categoriseren of voorspellen van een klasse voor onbekende tekstdocumenten, vaak met behulp van supervised machine learning.

Net als een classificatie-algoritme dat is getraind op een tabelvormige dataset om een klasse te voorspellen, maakt ook tekstclassificatie gebruik van supervised machine learning. Het feit dat er tekst wordt gebruikt bij tekstclassificatie is het belangrijkste verschil tussen de twee.

Je kunt tekstclassificatie ook uitvoeren zonder supervised machine learning. In plaats van algoritmen kun je een handmatig rule-based systeem ontwerpen om de taak van tekstclassificatie uit te voeren. We vergelijken en bespreken de voor- en nadelen van rule-based en machinelearning-gebaseerde tekstclassificatiesystemen in de volgende sectie.

Bron afbeelding

Wil je meer leren over supervised machine learning? Lees dan ons aparte artikel.

Use-cases en toepassingen van tekstclassificatie

Spamclassificatie

Er zijn veel praktische use-cases voor tekstclassificatie in tal van sectoren. Een spamfilter is bijvoorbeeld een veelvoorkomende toepassing die tekstclassificatie gebruikt om e-mails in spam- en niet-spamcategorieën te sorteren. 

Bron afbeelding

Nieuwsartikelen en blogs classificeren

Een andere use-case is het automatisch toewijzen van tekstdocumenten aan vooraf bepaalde categorieën. Een supervised machine learning-model wordt getraind op gelabelde data, met zowel de ruwe tekst als het doel. Zodra het model getraind is, wordt het in productie gebruikt om een categorie (label) te verkrijgen voor nieuwe, nog ongeziene data (artikelen/blogs die in de toekomst worden geschreven).

Bron afbeelding

Klantenservicetickets categoriseren

Een bedrijf kan tekstclassificatie gebruiken om supportverzoeken automatisch per onderwerp te categoriseren of om verzoeken te prioriteren en door te sturen naar de juiste afdeling. 

Bron afbeelding

Haatzaaiende uitingen detecteren

Met meer dan 1,7 miljard dagelijks actieve gebruikers is het onvermijdelijk dat er op Facebook content verschijnt die tegen de regels ingaat. Haatzaaiende uitingen vallen onder deze ongewenste content. 

Facebook pakt dit aan door een handmatige beoordeling te vragen van berichten die een AI-tekstclassificator als haatdragend heeft aangemerkt. Berichten die door AI zijn geflagd, worden op dezelfde manier beoordeeld als posts die door gebruikers zijn gerapporteerd. In slechts de eerste drie maanden van 2020 verwijderde het platform zelfs 9,6 miljoen items die als haatdragende uitingen waren geclassificeerd.

Bron afbeelding

Soorten tekstclassificatiesystemen

Er zijn grofweg twee soorten tekstclassificatiesystemen: rule-based en machinelearning-gebaseerde tekstclassificatie.

Rule-based tekstclassificatie

Rule-based technieken gebruiken een set handmatig opgestelde taalregels om tekst in categorieën of groepen in te delen. Deze regels vertellen het systeem op basis van semantisch relevante tekstelementen in welke categorie een tekst valt. Elke regel bestaat uit een antecedent of patroon en een voorspelde categorie.

Stel bijvoorbeeld dat je heel veel nieuwe artikelen hebt en dat je ze wilt toewijzen aan relevante categorieën zoals Sport, Politiek, Economie, enz. 

Met een rule-based classificatiesysteem beoordeel je handmatig een aantal documenten om taalkundige regels op te stellen zoals deze:

• Als het document woorden bevat als money, dollar, GDP of inflation, dan hoort het bij de groep (klasse) Politiek. 

Rule-based systemen kunnen in de loop van de tijd worden verfijnd en zijn voor mensen goed te begrijpen. Er zitten echter ook nadelen aan deze aanpak. 

Om te beginnen vereisen deze systemen diepgaande domeinkennis. Ze kosten veel tijd, omdat het maken van regels voor een complex systeem lastig kan zijn en vaak uitgebreid onderzoek en testen vereist. 

Omdat het toevoegen van nieuwe regels de uitkomsten van al bestaande regels kan veranderen, zijn rule-based systemen ook moeilijk te onderhouden en schalen ze niet goed.

Machinelearning-gebaseerde tekstclassificatie

Machinelearning-gebaseerde tekstclassificatie is een supervised machine learning-probleem. Het leert de mapping van invoergegevens (ruwe tekst) naar labels (ook wel doelvariabelen). Dit lijkt op niet-tekstuele classificatieproblemen waarbij we een supervised classificatie-algoritme trainen op een tabelvormige dataset om een klasse te voorspellen, met als uitzondering dat de invoer bij tekstclassificatie ruwe tekst is in plaats van numerieke features. 

Zoals bij elke supervised machine learning zijn er bij tekstclassificatie twee fasen: trainen en voorspellen.

Bron afbeelding

Trainingsfase

Tijdens de trainingsfase wordt een supervised machine learning-algoritme getraind op de gelabelde invoerdataset. Aan het einde van dit proces hebben we een getraind model dat we kunnen gebruiken om voorspellingen (labels) te verkrijgen op nieuwe, nog ongeziene data.

Voorspellingsfase

Zodra een machinelearningmodel is getraind, kan het worden gebruikt om labels te voorspellen voor nieuwe, nog ongeziene data. Dit gebeurt meestal door het beste model uit een eerdere fase als API op de server te deployen. 

Pipeline voor tekstvoorverwerking

Het voorbewerken van tekstdata is een belangrijke stap in elke NLP-taak. Het helpt bij het opschonen en voorbereiden van de tekstdata voor verdere verwerking of analyse. 

Een pipeline voor tekstvoorverwerking is een reeks verwerkingsstappen die worden toegepast op ruwe tekstdata om deze gereed te maken voor gebruik in NLP-taken. 

De stappen in een tekstvoorverwerkingspipeline kunnen variëren, maar omvatten meestal taken als tokenization, stopwoorden verwijderen, stemming en lemmatization. Deze stappen helpen de omvang van de tekstdata te verkleinen en verbeteren ook de nauwkeurigheid van NLP-taken zoals tekstclassificatie en informatie-extractie.

Tekstdata is lastig te verwerken omdat het ongestructureerd is en vaak veel ruis bevat. Die ruis kan bestaan uit spelfouten, grammaticale fouten en niet-standaard opmaak. Een tekstvoorverwerkingspipeline is erop gericht deze ruis op te schonen zodat de tekstdata gemakkelijker kan worden geanalyseerd.

Bron tekst

Meer leren? Bekijk onze track Text Mining with R. 

Feature-extractie

De twee meest gebruikte methoden om features uit tekst te extraheren, of anders gezegd om tekstdata (strings) om te zetten in numerieke features zodat een machinelearningmodel kan worden getraind, zijn: Bag of Words (ook wel CountVectorizer) en Tf-IDF. 

Bag of Words

Een bag-of-words (BoW)-model is een eenvoudige manier om tekstdata als numerieke features te representeren. Het houdt in dat je een vocabulaire maakt van bekende woorden in het corpus en vervolgens voor elk document een vector maakt met tellingen van hoe vaak elk woord voorkomt.

Bron afbeelding

TF-IDF

TF-IDF staat voor term frequency-inverse document frequency, en is een andere manier om tekst als numerieke features te representeren. Er zijn enkele tekortkomingen aan het Bag of Words (BoW)-model die door Tf-IDF worden ondervangen. We gaan daar in dit artikel niet diep op in, maar als je dit verder wilt verkennen, bekijk dan onze cursus Introduction to Natural Language Processing in Python.

Het TF-IDF-model verschilt van het bag-of-wordsmodel doordat het rekening houdt met de frequentie van woorden in het document én met de inverse documentfrequentie. Dit betekent dat het TF-IDF-model eerder de belangrijke woorden in een document identificeert dan het bag-of-wordsmodel.

End-to-end voorbeeld van tekstclassificatie in Python

Dataset importeren

Begin met het rechtstreeks importeren van de dataset via deze GitHub-link. De SMS Spam Collection is een dataset met 5.574 Engelstalige sms-berichten met het label Spam of Ham (geen spam). Ons doel is een machinelearningmodel te trainen dat leert van de tekst van de sms’en en het label, en vervolgens de klasse van sms-berichten kan voorspellen.

# reading data

import pandas as pd

data = pd.read_csv('https://raw.githubusercontent.com/mohitgupta-omg/Kaggle-SMS-Spam-Collection-Dataset-/master/spam.csv', encoding='latin-1')

data.head()

Na het inlezen van de dataset zie je dat er een paar extra kolommen zijn die we niet nodig hebben. We hebben alleen de eerste twee kolommen nodig. Laten we de overige kolommen verwijderen en de eerste twee kolommen hernoemen.

# drop unnecessary columns and rename cols

data.drop(['Unnamed: 2', 'Unnamed: 3', 'Unnamed: 4'], axis=1, inplace=True)

data.columns = ['label', 'text']

data.head()

Exploratory Data Analysis (EDA)

Laten we wat basis-EDA doen om te zien of er missende waarden in de dataset staan en hoe de balans van het target is.

# check missing values

data.isna().sum()

# check data shape

data.shape

>>> (5572, 2)

# check target balance

data['label'].value_counts(normalize = True).plot.bar()

Tekstvoorverwerking

Hier vindt alle tekstreiniging plaats. Het is een lus die door alle 5.572 documenten iterereert en het volgende doet:

• Alle speciale tekens verwijderen
• Alle woorden in kleine letters zetten
• Tokenizen
• Stopwoorden verwijderen
• Lemmatizen

# text preprocessing




# download nltk

import nltk

nltk.download('all')




# create a list text

text = list(data['text'])




# preprocessing loop

import re

from nltk.corpus import stopwords

from nltk.stem import WordNetLemmatizer

lemmatizer = WordNetLemmatizer()




corpus = []




for i in range(len(text)):

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

    r = r.lower()

    r = r.split()

    r = [word for word in r if word not in stopwords.words('english')]

    r = [lemmatizer.lemmatize(word) for word in r]

    r = ' '.join(r)

    corpus.append(r)




#assign corpus to data['text']

data['text'] = corpus

data.head()

Train-test-split

Laten we de dataset in train en test splitsen voordat we features extraheren.

# Create Feature and Label sets

X = data['text']

y = data['label']




# train test split (66% train - 33% test)

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=123)




print('Training Data :', X_train.shape)

print('Testing Data : ', X_test.shape)

>>> Training Data : (3733,)

>>> Testing Data :  (1839,)

Feature-extractie

Hier gebruiken we het Bag-of-Words-model (CountVectorizer) om de opgeschoonde tekst om te zetten in numerieke features. Dit is nodig om het machinelearningmodel te trainen.

# Train Bag of Words model

from sklearn.feature_extraction.text import CountVectorizer

cv = CountVectorizer()

X_train_cv = cv.fit_transform(X_train)

X_train_cv.shape

>>> (3733, 7020)

Modeltraining en evaluatie

In dit deel trainen we een Logistic Regression-model en beoordelen we de confusion matrix van het getrainde model.

# Training Logistic Regression model

from sklearn.linear_model import LogisticRegression

lr = LogisticRegression()

lr.fit(X_train_cv, y_train)




# transform X_test using CV

X_test_cv = cv.transform(X_test)




# generate predictions

predictions = lr.predict(X_test_cv)

predictions

>>> array(['ham', 'spam', 'ham', ..., 'ham', 'ham', 'spam'], dtype=object)

# confusion matrix

import pandas as pd

from sklearn import metrics

df = pd.DataFrame(metrics.confusion_matrix(y_test,predictions), index=['ham','spam'], columns=['ham','spam'])

df

Bekijk de volledige DataLab-werkmap voor meer details.

Conclusie

NLP is nog steeds een actief onderzoeks- en ontwikkelingsgebied, waarin veel universiteiten en bedrijven werken aan nieuwe algoritmen en toepassingen. NLP is interdisciplinair, met onderzoekers uit uiteenlopende achtergronden, waaronder informatica, taalkunde, psychologie en cognitieve wetenschappen.

Tekstclassificatie is een krachtige en veelgebruikte taak binnen NLP waarmee je automatisch een klasse kunt toekennen of voorspellen voor onbekende tekstdocumenten, vaak met behulp van supervised machine learning. 

Het is niet altijd perfect nauwkeurig, maar als je het goed inzet, kan het veel waarde toevoegen aan je analyses. Er zijn veel verschillende manieren en algoritmen om een tekstclassificator op te zetten, en er is geen enkele aanpak die altijd het beste is. Het is belangrijk om te experimenteren en te ontdekken wat het beste werkt voor jouw data en doel.