Dit artikel is gepubliceerd als onderdeel van het Data Science-blogathon.
Welkom bij de serie NLP-artikelen. tot nu toe hebben we de meervoudige tekstverwerkingstechnieken behandeld in de eerste artikel. In de tweede deel van de NLP-artikelreeks zagen we verschillende soorten feature-extractietechnieken en woordinbedding met python-codes.
Inhoudsopgave
- Onderdelen van spraakherkenning
- Naam Entiteit Erkenning
- Tekstclassificatie
Introductie
In dit artikel gaan we nog een stap verder en bespreken we enkele zeer belangrijke NLP-banen.
Nadat je een idee hebt gehad over meerdere technieken voor het extraheren van functies en het opschonen van tekst, is het tijd om wat NLP-taken uit te voeren. er is een grote verscheidenheid aan taken die we kunnen uitvoeren met NLP. sommige maken deel uit van spraaklabels, entiteitsextractie en tekstclassificatie.
Onderdeel van Speech Tagging
Part of speech (POS) tagging omvatte het labelen van de woorden met hun respectieve woordsoort, dwz. zelfstandig naamwoord, bijvoeglijk naamwoord, werkwoord, enz.
Het is een zeer cruciaal onderdeel van natuurlijke taalverwerking. Named Entity Recognition is gebaseerd op deze fenomenen die we verder in dit artikel zullen bespreken.
Sentimentanalyse, benoemde entiteitsresolutie, vraagbeantwoording, ondubbelzinnig maken van Word Sense is gebaseerd op spraakherkenning.
Er zijn 2 manieren om een POS-tagger te bouwen
- Op regels gebaseerd: gebaseerd op regels
- Stochastisch gebaseerd: gebaseerd op de volgorde van woorden met behulp van het verborgen Markov-model
Implementeren in Python
we hebben een document gegeven en we moeten elk woord taggen met hun woordsoort.
text = "Ik hou van NLP en probeer het te leren door artikelen te lezen"
Laten we, voordat we verder gaan, de stopwoorden eruit filteren.
#---de bibliotheek importeren------ nltk importeren #----- de stopwoorden laden--------- van nltk.corpus stopwords importeren stop_words = set(stopwords.words('english') ))
alle stopwoorden eruit filteren
from nltk.tokenize import word_tokenize,sent_tokenize #---De tokens van woorden genereren ------ woorden = nltk.word_tokenize(text) #-----De stopwoorden filteren woorden = [woord voor woord in woorden als w niet in stop_words] woorden
nltk.pos_tag() neemt het woord in een lijst en retourneert de woordsoort.
POS = [] voor woord in woorden: POS.append(nltk.pos_tag([word])) POS
Hier is het deel van de spraak geschreven in hun korte vorm:
- NNS → Zelfstandig naamwoord Meervoud dwz.Tabellen
- NN → Zelfstandig naamwoord Enkelvoud dwz.Tabel
- VBG → Werkwoord
- PRP → Voornaamwoord
Op basis van dit idee kunnen we verschillende woordsoorten uit een document extraheren, maar als we iets heel specifieks willen extraheren, stel dat we verschillende landnamen, namen van verschillende organisaties uit een document willen extraheren, kunnen we dit niet doen met behulp van POS-tagger, hier hebben we gebruik het idee van Named Entity Recognition.
Naam Entiteit Erkenning
Het extraheren van verschillende soorten entiteiten uit een document is gebaseerd op POS, maar het is in staat om een groot aantal entiteiten uit een document te identificeren. Het extraheren van alle namen, namen van landen uit een document.
Er zijn meerdere bibliotheken beschikbaar voor het uitvoeren van entiteitsextractie.ie SpaCy, NLTK chunker, StanfordNER enz.
we zullen gebruiken SpaCy omdat het eenvoudig te implementeren is en betere resultaten geeft
Implementatie met Python
#-----SpaCy installeren ---- !pip install spacy !spacy download en_core_web_sm
#---- Laden van de Spacy Pipeline Importeer spacy nlp = spacy.load('en_core_web_sm')
spacy.load(‘language_model’) geeft een taalpijplijn terug.
text = "Samsung is klaar om een nieuwe telefoon ter waarde van $ 1000 te lanceren in Zuid-Korea" doc = nlp(text) for ent in doc.ents: print(ent.text, ent.label_)
doc.ents→ lijst van de tokensent.label_→ entiteitsnaament.text→ symbolische naam
Alle tekst moet worden omgezet in Spacy Document door in de pijplijn te gaan.
- ORG → Organisatie
- 1000 → Geld
- Zuid-Korea → Geopolitieke entiteit
SpaCy geeft nauwkeurige resultaten en kan worden gebruikt waar het ons doel is om entiteiten uit te filteren.
Tekstclassificatie
Hier is het de bedoeling om een tekst te classificeren op basis van de vooraf getrainde categorie. Er is een grote verscheidenheid aan toepassingen op basis van tekstclassificatie.
- Hervatten op de shortlist
- Spamclassificatie
- Documentclassificatie
- Sentiment analyse
Je hebt misschien gezien dat er een map is voor alle spamberichten in je berichteninbox, een machine learning-model werkt in de backend die spammails classificeert versus onze normale e-mails.
Een spam-mailclassificatie bouwen in Python
Om een model te trainen hebben we een dataset nodig met daarin alle spamberichten en normale berichten. we zullen een basislijntekstclassificator trainen om het trainingsproces te begrijpen.
1. Download de dataset van hier in uw werkmap.
2. Importeer de benodigde bibliotheken om de dataset in een panda-dataframe te laden en gegevens op te schonen.
importeer panda's als pd df = pd.read_csv(r'spam.csv',encoding='ISO-8859-1',usecols=['v1','v2']) df.rename(columns = {'v1': 'Doel', 'v2':'E-mail'}, inplace = True)
Zoals u ziet, worden onze onbewerkte gegevens niet opgeschoond, we moeten enkele bewerkingen voor het opschonen van gegevens uitvoeren.
df.Target.value_counts()
In de dataset zijn de meeste rijen normale mails, slechts 747 mails zijn spam. Onze dataset is onevenwichtig. Dit kan worden opgelost door upsampling of downsampling, wat we in het volgende deel zullen doen.
3. voor het opschonen van tekst heb ik een bibliotheek gemaakt text-hammer dat maakt het opschonen van onze tekst veel gemakkelijker. het installeren en gebruiken van deze bibliotheek is zo eenvoudig.
!pip install text_hammer import text_hammer als th
Een functie maken voor het opschonen van tekst
def text_cleaning(df,col_name): #-----Remove Stopwords---- df[col_name] = df[col_name].progress_apply(lambda x: th.remove_stopwords(x)) #----Verwijder speciaal teken ---- df[col_name] = df[col_name].progress_apply(lambda x: th.remove_special_chars(x)) #---Verwijder tekens met accenten--- df[col_name] = df[col_name].progress_apply(lambda x : th.remove_accented_chars(x)) # --- HTML-tags en URL verwijderen--- df[col_name] = df[col_name].progress_apply(lambda x: th.remove_html_tags(x)) df[col_name] = df[col_name ].progress_apply(lambda x: th.remove_urls(x)) #--- Converteren naar hoofdwoorden-- df[col_name] = df[col_name].progress_apply(lambda x: th.make_base(x)) return df
De functie voor het opschonen van tekst oproepen: text_cleaning neemt een df en de kolomnaam met de onbewerkte gegevens.
df = text_cleaning(df, 'E-mail')
De spam in kaart brengen met 1 en ham met 0.
df['Target'] = df.Target.map({'ham':0,'spam':1})
Alle gegevens splitsen voor training en testen
gebruik train_test_split om de dataset op te splitsen in trainings- en testdoeleinden.
# splitsen van de gegevens om ons definitieve model te controleren from sklearn import model_selection X_train,X_test,y_train,y_test = model_selection.train_test_split(df['Email'],df['Target'], stratify = df['Target'], test_size = 0.2, random_state = 42)
X_train,y_trainzijn de gegevens die zullen worden gebruikt voor trainingsdoeleinden.X_test,y_testzal worden gebruikt voor voorspellingsdoeleinden.
Een training maken Pijpleiding
Door Pipelines te maken, kunnen we meerdere stappen in één enkele combineren. Dezelfde Pipeline kan worden gebruikt voor training en voor voorspelling.
Hier hebben we Feature Extraction en modeltraining gecombineerd in één stap met behulp van een pijplijn.
van sklearn.feature_extraction.text import TfidfVectorizer van sklearn.naive_bayes import MultinomialNB van sklearn.pipeline import Pipeline vectorizer = TfidfVectorizer() classifier = Pipeline([('feature_generation', vectorizer), ('model',MultinomialNB())])
- Multinomiaal NB Hier gebruiken we het Multinomial Naive Bayes-model voor onze classificatietaak, Naive Bayes-modellen presteren goed voor discrete klassen, Lees verder.
- De pijplijn bevat 2 functies. Doorgegeven gegevens worden eerst omgezet in functies met behulp van TF-IDF vectorizer en vervolgens worden de functies doorgegeven aan het MultinomialNB-model.
De pijplijn trainen
classifier.fit(X_train,y_train)
Voorspelling
Na het trainen van de classifier kunnen we dezelfde pijplijn gebruiken voor de voorspelling.
text = ['Hey Abhishek kunnen we samen naar een voetbalwedstrijd kijken', 'Gratis deelname aan 2 a wekelijkse competitie om de FA Cup-finale te winnen'] classifier.predict(text)
De voorspellen methode voert een lijst met teksten in en voorspelt in de vorm van 0 (normaal),1 (spam).
de eerste zin is geen spammail, dus voorspeld 0 en de tweede is voorspeld als spam 1.
Prestatiestatistieken
sklearn biedt een metrische klasse om te zien hoe ons model presteert op een dataset.
classification_report neemt true_label en predicted_label als invoer en druk een rapport af.
van sklearn metrische gegevens importeren y_predicted = classifier.predict(X_test) print(metrics.classification_report(y_test,y_predicted))
Zoals u ziet, kan ons model normale e-mails met grote zekerheid voorspellen, maar de voorspelling van spamberichten blijft een beetje achter vanwege de onevenwichtige gegevens.
van sklearn.metrics import verwarring_matrix resultaten = verwarring_matrix(y_test, y_predicted) print(resultaten)
Verwarringsmatrix geeft aan dat ons model 177 spamberichten correct classificeert, 61 spamberichten verkeerd worden geclassificeerd en 1434 normale berichten correct worden geclassificeerd.
Modelevaluatie
het model dat we zojuist hebben getraind met behulp van de sklearn-pijplijn is een basislijnmodel. we kunnen de resultaten zeker verbeteren door de volgende stappen te nemen:
- Het gebruik van Word-Inbedding kan ons betere resultaten geven
- Elimineer de gegevensonbalans
- Een op deep learning gebaseerd model gebruiken, dwz. LSTM, BERT, enz.
Eindnoot
In dit artikel hebben we tekstclassificatie besproken, waaronder Part of speech tagging, Entity-extractie met behulp van Spacy en we hebben een model gebouwd voor het classificeren van spamberichten. het model dat we bouwen is slechts een basismodel, we verbeteren het zeker verder. het maken van pijplijnen is een goede gewoonte tijdens het trainen van het model, omdat het meerdere stappen combineert.
In het volgende artikel bespreken we
- Modellering van onderwerpen
- Tekst-naar-spraak
- Taaldetectie en vertaling
Schrijf me gerust op Linkedin.
De in dit artikel getoonde media zijn geen eigendom van Analytics Vidhya en worden naar goeddunken van de auteur gebruikt.
