Dit artikel is gepubliceerd als onderdeel van het Data Science-blogathon.

Hey mensen!

Welkom bij de NLP van nul tot geavanceerde serie over analytics Vidhya, waar we alle NLP-onderwerpen behandelen, van beginner tot gevorderd niveau.

In het vorige artikel hebben we verschillende tekstverwerkingstechnieken gezien met voorbeelden. Als je het nog niet hebt gelezen, is hier de link.

We zijn in staat om onbewerkte gegevens op te schonen en om opgeschoonde tekstgegevens te krijgen. nu is het tijd om de tweede stap te zetten.

Inhoudsopgave

1. Functie extractie
2. Zak met Word-model
3. concept van n-gram
4. Tel Vectorizer-methode
5. TF-IDF
6. Word insluiten met python-code

Alle onderwerpen worden gedetailleerd uitgelegd met python-codes en afbeeldingen.

Feature Engineering is een zeer belangrijk onderdeel van Natural Language Processing. zoals we allemaal weten, kunnen algoritmen en machines geen tekens of woorden of zinnen begrijpen, daarom moeten we deze woorden coderen in een specifieke vorm van numeriek om te kunnen communiceren met algoritmen of machines. we kunnen de tekstgegevens die woorden /zinnen/tekens bevatten niet aan een machine learning-model toevoegen.

Er zijn verschillende manieren om feature-extractie uit te voeren. enkele populaire en meest gebruikte zijn: -

1. Zak met woorden-model
2. TF-IDF

1. Bag of Words (BOW) model

Het is het eenvoudigste model. Stel je een zin voor als een reeks woorden. Het idee is om de hele tekstgegevens te nemen en de frequentie van voorkomen te tellen. en breng de woorden in kaart met hun frequentie. Deze methode geeft niet om de volgorde van de woorden, maar het maakt wel uit hoe vaak een woord voorkomt en het standaard woordenzakje-model behandelt alle woorden gelijk.

De feature vector zal dezelfde woordlengte hebben. Woorden die meerdere keren voorkomen, krijgen een hoger gewicht, waardoor dit model bevooroordeeld is, wat is opgelost met TF-IDF die verder wordt besproken.

Implementatie van het BOW-model met Python:

sklearn biedt alle benodigde functie-extractietechnieken met eenvoudige implementatie.

!pip install sklearn importeer sklearn van sklearn.feature_extraction.text import CountVectorizer vectorizer = CountVectorizer()

Importeren CountVectorizer om het Bag of Words-model te implementeren.

text = ["ik hou van NLP", "NLP is toekomst", "ik zal leren in 2 maanden"] vectorizer = CountVectorizer() count_matrix = vectorizer.fit_transform(text) count_array = count_matrix.toarray() df = pd.DataFrame( data=count_array,columns = vectorizer.get_feature_names()) print(df)

• de methode fit_transform()past de gegevens eerst aan countVectorizer aan en converteert deze vervolgens naar functies
• de methode get_features_name() geeft de woordenschat van unieke woorden terug.
• als countVectorizer eenmaal is aangebracht, zou het de Bag of Words niet bijwerken.
• stopwords we kunnen een lijst met stopwoorden doorgeven of een taalnaam opgeven, dwz {'english'}om stopwoorden uit het vocabulaire uit te sluiten.

Na het aanpassen van de countVectorizer kunnen we elke tekst omzetten in het gepaste vocabulaire.

text2 = ['Ik hou van NLP, maar kan het niet leren in 2 maanden'] vectorizer.transform(text2).toarray()

In het bovenstaande voorbeeld van het BOW-model wordt elk woord als één kenmerk beschouwd, maar er zijn enkele problemen met dit model.

Stel bijvoorbeeld dat we het woord "niet slecht" hebben en als we dit opsplitsen in "niet" en "slecht" dan verliest het zijn betekenis. "niet slecht" is tot op zekere hoogte vergelijkbaar met "goed". we willen zulke woorden die na het splitsen hun betekenis verliezen, niet splitsen. hier het idee van n-gram komt in beeld.

• Unigrammen zijn de enkele unieke woorden in een zin
• Bigrams zijn de combinatie van 2 woorden, dwz "niet slecht", "uitschakelen".
• Trigrammen zijn de combinatie van 3 woorden.

tijdens het implementeren van het BOW-model met CounVectorizer kunnen we n-grammen opnemen in de woordenschat met behulp van ngram_range parameter.

Implementatie van het BOW-model met n-gram:

• ngram_range =(1, 1) betekent alleen unigrammen,
• ngram_range = (1, 2) betekent unigrams met bigrams
• ngram_range=(2, 2) betekent alleen bigrams.

text = ["eten was niet slecht"] vectorizer = CountVectorizer(ngram_range = (1,2)) count_matrix = vectorizer.fit_transform(text) count_array = count_matrix.toarray() df = pd.DataFrame(data=count_array,columns = vectorizer .get_feature_names()) print(df)

2. TF-IDF (Termijn frequentie-inverse documentfrequentie)

Het BOW-model geeft geen goede resultaten omdat het een nadeel heeft. Stel dat er een bepaald woord in alle documenten voorkomt en het komt meerdere keren voor, uiteindelijk zal het vaker voorkomen en zal het een grotere waarde hebben waardoor een specifiek woord meer gewicht krijgt in een zin , dat is niet goed voor onze analyse.

Het idee van TF-IDF is om het belang van een woord voor zijn document of zin weer te geven door de woorden te normaliseren die vaak voorkomen in het verzamelen van documenten.

Term frequentie (TF): aantal keren dat een term in een document is voorgekomen.

De term frequentie is een maat voor hoe vaak of hoe vaak een woord voor een bepaalde zin is.

Inverse documentfrequentie (IDF):

De inverse document frequency (IDF) is een maatstaf voor hoe zeldzaam een ​​woord in een document voorkomt. Woorden als 'de', 'a' komen in alle documenten voor, maar zeldzame woorden zullen niet in alle documenten van het corpus voorkomen.

Als een woord in bijna elk document voorkomt, betekent dit dat het niet significant is voor de classificatie.

IDF van een woord is = log(N/n)

• N: totaal aantal documenten.
• n: aantal documenten met een term (woord)

TF-IDF Evalueert hoe relevant een woord is voor zijn zin in een verzameling zinnen of documenten.

TF-IDF implementeren met python:

Met Tfidftransformer berekent u het aantal woorden met CountVectorizer en berekent u vervolgens de IDF-waarden en pas daarna de Tf-IDF-scores. Met Tfidfvectorizer doen we alle berekeningen in één stap.

sklearn biedt 2 klassen voor het implementeren van TF-IDF:

• Tfidftransformer waar we het aantal woorden moeten berekenen, vervolgens IDF-waarden moeten berekenen en vervolgens de TF-IDF-scores moeten berekenen.
• Tfidfvectorizer hier worden alle stappen in één stap gedaan.

Bibliotheken importeren :

importeer sklearn importeer panda's als pd van sklearn.feature_extraction.text importeer TfidfVectorizer

Implementatie :

text = ["ik hou van NLP", "NLP is de toekomst", "ik zal NLP leren"] vectorizer = TfidfVectorizer() matrix = vectorizer.fit_transform(text) count_array = matrix.toarray() df = pd.DataFrame (data=count_array,columns = vectorizer.get_feature_names()) print(df)

"NLP", "de" kwam in alle drie de documenten voor en heeft daarom een ​​kleinere vectorwaarde. ”liefde” heeft een hogere vectorwaarde omdat het maar één keer in een document voorkwam.

3. Woordinbedding

Stel je voor dat ik 2 woorden "love" en "like" heb, deze twee woorden hebben bijna dezelfde betekenis, maar volgens het TF-IDF- en BOW-model hebben deze twee afzonderlijke functiewaarden en worden deze twee woorden totaal anders behandeld.

TF-IDF, BOW-model hangt volledig af van de frequentie van voorkomen, het houdt geen rekening met de betekenis van woorden, daarom slagen de hierboven besproken technieken er niet in om de context en betekenis van zinnen vast te leggen.

"ik vind je leuk"En"ik hou van je” zal volgens het TF-IDF- en BOW-model totaal verschillende kenmerkvectoren hebben, maar dat is niet correct.

opmerking: als we met een classificatietaak werken, zouden we grote onbewerkte gegevens hebben en als we elk synoniem als een ander woord blijven beschouwen, zal het gigantische aantallen tokens genereren en dit zal ervoor zorgen dat het aantal functies uit de hand loopt.

Woordinbedding is een leertechniek voor functies waarbij woorden worden toegewezen aan vectoren met behulp van hun contextuele hiërarchie. vergelijkbare woorden hebben identieke kenmerkvectoren.

Zoals je merkt, katten en katje zijn zeer nauw geplaatst omdat ze verwant zijn.

woordinbedding wordt getraind op meer dan 6 miljard woorden met behulp van ondiepe neurale netwerken.

word2vec heeft 2 algoritmen

• CBOW
• Skip-gram

maak je geen zorgen, we hoeven woord2vec niet te trainen, we zullen vooraf getrainde woordvectoren gebruiken.

Word2vec implementeren met python:

Een vooraf getrainde woordvector is een tekstbestand dat miljarden woorden met hun vectoren bevat. we hoeven alleen woorden uit onze gegevens in kaart te brengen met de woorden in de woordvector om de vectoren te krijgen.

je kunt het word-vectorbestand downloaden of je kunt hiermee een notitieboekje maken link.

Bron: Kaggle

Vooraf getraind woordvectorbestand heeft een (50,100,200,300) dimensie. hier is dimensie de lengte van de vector van elk woord in de vectorruimte. meer dimensie betekent meer informatie over dat woord, maar grotere dimensie kost meer tijd voor modeltraining.

1. Handschoenwoord inbedden van 100 dimensies in een woordenboek laden:

importeer numpy als np glove_vectors = dict() file = open('../input/glove6b/glove.6B.100d.txt', encoding = 'utf-8') voor regel in bestand: values ​​= line.split() woord = waarden[0] vectoren = np.asarray(waarden[1:]) handschoen_vectoren[woord] = vectoren file.close()

Het Python-woordenboek maakt mapping eenvoudig, daarom heeft het altijd de voorkeur om in het woordenboek te laden.

• we kunnen de get() methode om glove_vectors om de vectoren te krijgen

handschoen_vectoren.get('huis')

we delen de vectoren door het aantal woorden in die specifieke zin/document voor normalisatiedoeleinden.

2. Een functie maken die elke zin opneemt en woordvectoren retourneert:

vec_dimension = 100 def get_vec(x): arr = np.zeros(vec_dimension) text = str(x).split() voor t in tekst: probeer: vec = glove_vectors.get(t).astype(float) arr = arr + vec behalve: pass arr = arr.reshape(1,-1)[0] return(arr/len(text))

document:

x = ['Ik hou van jou', 'Ik hou van NLP en ik zal proberen te leren', 'dit is woord insluiten'] features = get_vec(x) features

Deze getallen zijn de kenmerken van document x, de lengte van de kenmerken is 100 aangezien we 100 dimensies hebben gebruikt.

notitieboekje downloaden

EndNote

In dit artikel hebben we verschillende functies voor het extraheren van functies gezien. we bespraken het idee van woordenschat en het probleem met het BOW-model, toen zagen we het concept van n-grammen en hoe n-grammen te gebruiken in het BOW-model in python. we bespraken het TF-IDF-model en bespraken vervolgens de Word-Embedding met behulp van vooraf getrainde functies in python.

Al deze feature-extractietechnieken zijn gemakkelijk beschikbaar in het sklearn-pakket. voor het insluiten van woorden kunnen we vooraf getrainde word2vec-functies gebruiken, zoals we hebben besproken.

In het volgende artikel zullen we feature-extractie in de actie zien. we zullen een machine learning-model trainen dat spam-e-mails kan classificeren.

Als je suggesties of vragen voor me hebt, schrijf me dan op Linkedin.

De in dit artikel getoonde media zijn geen eigendom van Analytics Vidhya en worden naar goeddunken van de auteur gebruikt. 

Verwant

Bron: https://www.analyticsvidhya.com/blog/2022/01/nlp-tutorials-part-ii-feature-extraction/