Gensim wordt gefactureerd als een Natural Language Processing pakket dat ‘Topic Modeling for Humans’ doet. Maar het is in de praktijk veel meer dan dat. Het is een toonaangevend en geavanceerd pakket voor het verwerken van teksten, het werken met woordvectormodellen (zoals Word2Vec, FastText enz.) en voor het bouwen van onderwerpmodellen.

Gensim Tutorial – A Complete Beginners Guide. Foto door Jasmin Schreiber

Inhoud

1. Inleiding
2. Wat is een woordenboek en een corpus?
3. Hoe maak je een woordenboek van een lijst zinnen?
4. Hoe maak je een woordenboek van een of meer tekstbestanden?
5. Hoe maak je een bag of words corpus in gensim?
6. Hoe maak je een woordenzak-corpus uit een extern tekstbestand?
7. Hoe bewaar je een woordenboek en corpus in Gensim op schijf en laad je ze terug?
8. Hoe maak je een TFIDF matrix (corpus) in Gensim?
9. Hoe gebruik je de Gensim downloader API om datasets te laden?
10. Hoe maak je bigrammen en trigrammen met behulp van Phraser modellen?
11. Hoe maak je onderwerp modellen met LDA?
12. Hoe interpreteer je de uitvoer van het LDA Topic Model?
13. Hoe maak je een LSI topic model met behulp van gensim?
14. Hoe kan ik een Word2Vec model trainen met behulp van gensim?
15. Hoe kan een bestaand Word2Vec model met nieuwe gegevens worden bijgewerkt?
16. Hoe woordvectoren extraheren met vooraf getrainde Word2Vec en FastText modellen?
17. Hoe documentvectoren maken met Doc2Vec?
18. Hoe bereken je similariteitsmetingen zoals cosinus similariteit en zachte cosinus similariteit?
19. Hoe kunnen tekstdocumenten worden samengevat?
20. Conclusie

Inleiding

Wat is gensim?

Gensim wordt gefactureerd als een Natural Language Processing pakket dat ‘Topic Modeling for Humans’ doet. Maar het is in de praktijk veel meer dan dat.

Als je niet bekend bent met topic modeling, het is een techniek om de onderliggende onderwerpen te extraheren uit grote hoeveelheden tekst. Gensim biedt algoritmen zoals LDA en LSI (die we later in deze post zullen zien) en de nodige verfijning om topic-modellen van hoge kwaliteit te bouwen.

Je kunt aanvoeren dat topic-modellen en woordinbedding beschikbaar zijn in andere pakketten zoals scikit, R enz. Maar de breedte en reikwijdte van faciliteiten om topic modellen te bouwen en te evalueren zijn ongeëvenaard in gensim, plus veel meer handige faciliteiten voor tekstverwerking.

Het is een geweldig pakket voor het verwerken van teksten, het werken met woordvector modellen (zoals Word2Vec, FastText etc) en voor het bouwen van topic modellen.

Een ander belangrijk voordeel van gensim is dat je er grote tekstbestanden mee kunt verwerken zonder het hele bestand in het geheugen te hoeven laden.

De bedoeling van dit artikel is om een praktisch overzicht te geven van bijna alle belangrijke functies, uitgelegd op een eenvoudige en gemakkelijk te begrijpen manier.

Aan het eind van deze tutorial zou je het volgende weten:

• Wat zijn de kernconcepten in gensim?
• Wat is een woordenboek en een corpus, waarom zijn ze belangrijk en waar kan je ze gebruiken?
• Hoe maak je en werk je met woordenboeken en corpussen?
• Hoe tekstgegevens uit meerdere tekstbestanden te laden en ermee te werken op een geheugenefficiënte manier
• Onderwerpsmodellen maken met LDA en de uitkomsten interpreteren
• TFIDF-model, bigrammen, trigrammen, Word2Vec-model, Doc2Vec-model maken
• Gelijkenis-metrieken berekenen
• En nog veel meer.

Laten we beginnen.

Wat is een Dictionary en Corpus?

Om met tekstdocumenten te kunnen werken, moet Gensim de woorden (aka tokens) omzetten in unieke id’s. Om dat te bereiken, laat Gensim je een Dictionary-object maken dat elk woord aan een uniek id koppelt.

We zullen in de volgende sectie zien hoe je dit feitelijk doet.

Maar waarom is het dictionary-object nodig en waar kan het worden gebruikt?

Het dictionary-object wordt typisch gebruikt om een ‘bag of words’-corpus te maken. Het is deze Dictionary en de bag-of-words (Corpus) die worden gebruikt als input voor topic modeling en andere modellen waarin Gensim is gespecialiseerd.

Al goed, wat voor soort tekstinput kan Gensim aan? De input tekst komt typisch in 3 verschillende vormen:

1. Als zinnen opgeslagen in python’s native lijst object
2. Als een enkel tekstbestand, klein of groot.
3. In meerdere tekstbestanden.

Nu, wanneer uw tekstinvoer groot is, moet u in staat zijn om het woordenboekobject te maken zonder het hele tekstbestand te hoeven laden.

Het goede nieuws is dat Gensim u de tekst laat lezen en het woordenboek laat bijwerken, regel voor regel, zonder het hele tekstbestand in het systeemgeheugen te laden. Laten we eens kijken hoe dat te doen in de volgende 2 secties.

Maar, voordat we beginnen, laten we wat NLP jargon begrijpen.

Een ’token’ betekent meestal een ‘woord’. Een ‘document’ kan typisch verwijzen naar een ‘zin’ of ‘paragraaf’ en een ‘corpus’ is typisch een ‘verzameling van documenten als een zak woorden’. Dat wil zeggen, voor elk document bevat een corpus het id van elk woord en zijn frequentietelling in dat document. Als gevolg daarvan gaat informatie over de volgorde van woorden verloren.

Als alles tot nu toe duidelijk is, laten we onze handen nat maken en kijken hoe we het woordenboek kunnen maken van een lijst zinnen.

Hoe maak je een woordenboek van een lijst zinnen?

In gensim bevat het woordenboek een map van alle woorden (tokens) naar zijn unieke id.

U kunt een woordenboek maken van een paragraaf van zinnen, van een tekstbestand dat meerdere regels tekst bevat en van meerdere van dergelijke tekstbestanden die in een directory staan. Voor het tweede en derde geval zullen we het doen zonder het hele bestand in het geheugen te laden, zodat het woordenboek wordt bijgewerkt als je de tekst regel voor regel leest.

Laten we beginnen met de ‘Lijst van zinnen’ input.

Wanneer je meerdere zinnen hebt, moet je elke zin omzetten naar een lijst van woorden. List comprehensions is een gebruikelijke manier om dit te doen.

Zoals het er staat heeft het woordenboek 34 unieke tokens (of woorden). Laten we de unieke ids voor elk van deze tokens bekijken.

We hebben met succes een Dictionary-object gemaakt. Gensim zal dit woordenboek gebruiken om een bag-of-words corpus te maken waar de woorden in de documenten worden vervangen door de respectievelijke id die door dit woordenboek wordt geleverd.

Als je in de toekomst nieuwe documenten krijgt, is het ook mogelijk om een bestaand woordenboek bij te werken om de nieuwe woorden op te nemen.

Hoe maak je een woordenboek van een of meer tekstbestanden?

Je kunt ook een woordenboek maken van een tekstbestand of van een map met tekstbestanden.

Het onderstaande voorbeeld leest een bestand regel voor regel en gebruikt Gensim’s simple_preprocess om één regel van het bestand tegelijk te verwerken.

Het voordeel hiervan is dat je een heel tekstbestand kunt lezen zonder het bestand in één keer in het geheugen te laden.

Laten we een sample.txt bestand gebruiken om dit te demonstreren.

We hebben een woordenboek gemaakt van één enkel tekstbestand. Mooi!

Nu, hoe lees je één regel per keer uit meerdere bestanden?

Aannemende dat je alle tekstbestanden in dezelfde directory hebt, moet je een klasse definiëren met een __iter__ methode. De methode __iter__() moet alle bestanden in een gegeven directory doorlopen en de verwerkte lijst van woord-tokens opleveren.

Laten we zo’n klasse definiëren met de naam ReadTxtFiles, die het pad naar de directory met de tekstbestanden opneemt. Ik gebruik deze directory van sportvoeding docs als input.

Deze blog post geeft een mooi overzicht om het concept van iterators en generatoren te begrijpen.

Hoe maak je een bag of words corpus in gensim?

Nu weet je hoe je een woordenboek maakt van een lijst en van een tekstbestand.

Het volgende belangrijke object waar je vertrouwd mee moet raken om in gensim te kunnen werken is het Corpus (een Zak Woorden). Dat wil zeggen, het is een corpus-object dat het woord-id en de frequentie ervan in elk document bevat. Je kunt het zien als Gensim’s equivalent van een Document-Term matrix.

Als je eenmaal het bijgewerkte woordenboek hebt, hoef je alleen nog maar de getoken lijst met woorden door te geven aan Dictionary.doc2bow()

Laten we een Corpus maken voor een eenvoudige lijst (my_docs) die 2 zinnen bevat.

Hoe moet het bovenstaande corpus worden geïnterpreteerd?

De (0, 1) in regel 1 betekent dat het woord met id=0 eenmaal voorkomt in het eerste document.
Ook de (4, 4) in het tweede lijst-item betekent dat het woord met id 4 viermaal voorkomt in het tweede document. Enzovoort.

Wel, dit is niet menselijk leesbaar. Om de id’s in woorden om te zetten, heb je het woordenboek nodig.

Laten we eens kijken hoe we de originele teksten terugkrijgen.

word_counts = , count) for id, count in line] for line in mycorpus]pprint(word_counts)#> , ]

Merk op, de volgorde van de woorden gaat verloren. Alleen het woord en zijn frequentie informatie blijft behouden.

6. Hoe maak je een bag of words corpus van een tekstbestand?

Het lezen van woorden uit een python lijst is vrij eenvoudig omdat de hele tekst al in het geheugen zat.
Het kan echter voorkomen dat je een groot bestand hebt waarvan je niet het hele bestand in het geheugen wilt laden.

Je kunt zulke bestanden regel voor regel importeren door een klasse te definiëren en de __iter__ functie die iteratief het bestand regel voor regel leest en een corpus object oplevert. Maar hoe maak je het corpus object?

De __iter__() van BoWCorpus leest een regel uit het bestand, verwerkt die tot een lijst van woorden met simple_preprocess() en geeft die door aan de dictionary.doc2bow(). Kun je verwant zijn aan hoe dit is vergelijkbaar en verschillend van de ReadTxtFiles klasse die we eerder hebben gemaakt?

Ook, merk op dat ik de smart_open() van smart_open pakket gebruik, omdat, het laat je grote bestanden openen en regel-voor-regel lezen van een verscheidenheid van bronnen, zoals S3, HDFS, WebHDFS, HTTP, of lokale en gecomprimeerde bestanden. Dat is behoorlijk geweldig trouwens!

Hoe dan ook, als je open() had gebruikt voor een bestand in je systeem, zal het perfect werken bestand ook.

Hoe een gensim woordenboek en corpus op te slaan op schijf en terug te laden?

Dit is vrij rechttoe rechtaan. Zie de voorbeelden hieronder.

We hebben de dictionary en corpus objecten opgeslagen. Laten we ze weer laden.

Hoe maak je de TFIDF matrix (corpus) in gensim?

De Term Frequency – Inverse Document Frequency(TF-IDF) is ook een bag-of-words model, maar in tegenstelling tot de reguliere corpus, TFIDF naar beneden gewogen tokens (woorden) die vaak voorkomt in documenten.

Hoe wordt TFIDF berekend?

Tf-Idf wordt berekend door vermenigvuldiging van een lokale component zoals term frequentie (TF) met een globale component, dat wil zeggen, inverse document frequentie (IDF) en optioneel normaliseren van het resultaat tot lengte-eenheid.

Als gevolg van deze, de woorden die vaak voorkomen in de documenten zal naar beneden worden gewogen.

Er zijn meerdere variaties van formules voor TF en IDF bestaan. Gensim maakt gebruik van het SMART Information retrieval systeem dat kan worden gebruikt om deze variaties te implementeren. U kunt opgeven welke formule moet worden gebruikt door de smartirs parameter in de TfidfModel te specificeren. Zie help(models.TfidfModel) voor meer details.

Dus, hoe krijg je de TFIDF gewichten?

Door het corpus te trainen met models.TfidfModel(). Pas vervolgens het corpus toe binnen de vierkante haakjes van het getrainde tfidf model. Zie onderstaand voorbeeld.

Opvallend is het verschil in gewichten van de woorden tussen het originele corpus en het tfidf gewogen corpus.

De woorden ‘is’ en ‘de’ komen in twee documenten voor en werden gewogen. Het woord ‘dit’, dat in alle drie documenten voorkomt, werd volledig verwijderd. Eenvoudig gezegd, woorden die vaker voorkomen in de documenten krijgen kleinere gewichten.

Hoe gebruik je gensim downloader API om datasets te laden?

Gensim biedt een ingebouwde API om populaire tekst datasets en woord inbeddingsmodellen te downloaden.

Een uitgebreide lijst van beschikbare datasets en modellen wordt hier bijgehouden.

Het gebruik van de API om de dataset te downloaden is zo simpel als het aanroepen van de api.load() methode met de juiste data of modelnaam.

Het onderstaande voorbeeld laat zien hoe het ‘handschoen-wiki-gigaword-50’ model kan worden gedownload.

Hoe maak je bigrammen en trigrammen met behulp van Phraser modellen?

Nu weet je hoe je datasets en voorgetrainde modellen kunt downloaden met gensim.

Laten we de text8 dataset downloaden, die niets anders is dan de “Eerste 100.000.000 bytes van platte tekst van Wikipedia”. Vervolgens zullen we hieruit bigrammen en trigrammen genereren.

Maar wat zijn bigrammen en trigrammen? en waarom zijn ze van belang?

In alinea’s hebben bepaalde woorden altijd de neiging om in paren (bigram) of in groepen van drie (trigram) voor te komen. Omdat de twee woorden samen de eigenlijke entiteit vormen. Bijvoorbeeld: Het woord ‘Frans’ verwijst naar de taal of regio en het woord ‘revolutie’ kan verwijzen naar de planetaire revolutie. Maar als je ze combineert, ‘Franse Revolutie’, verwijst dat naar iets heel anders.

Het is heel belangrijk om bigrammen en trigrammen te vormen uit zinnen, vooral als je werkt met bag-of-words-modellen.

Dus hoe maak je de bigrammen?

Het is heel gemakkelijk en efficiënt met het Phrases-model van Gensim. Het Phrases-model kan worden geïndexeerd, dus geef de oorspronkelijke tekst (lijst) door aan het Phrases-model om de bigrammen te vormen. Een voorbeeld staat hieronder:

De bigrammen zijn klaar. Kun je raden hoe je een trigram maakt?

Wel, gewoon spoelen en dezelfde procedure herhalen voor de uitvoer van het bigrammodel. Als je de bigrammen hebt gegenereerd, kun je de output doorgeven om een nieuw Phrases model te trainen. Pas dan het bigram corpus toe op het getrainde trigram model. In de war? Zie het voorbeeld hieronder.

Hoe maak je topic-modellen met LDA?

Het doel van topic-modellen is om de onderliggende onderwerpen te extraheren uit een gegeven verzameling tekstdocumenten. Elk document in de tekst wordt beschouwd als een combinatie van onderwerpen en elk onderwerp wordt beschouwd als een combinatie van gerelateerde woorden.

Topic modeling kan worden gedaan door algoritmen zoals Latent Dirichlet Allocation (LDA) en Latent Semantic Indexing (LSI).

In beide gevallen moet u het aantal onderwerpen als invoer opgeven. Het topic model zal op zijn beurt de topic keywords voor elk topic en de procentuele bijdrage van topics in elk document leveren.

De kwaliteit van topics is sterk afhankelijk van de kwaliteit van de tekstverwerking en het aantal topics dat je aan het algoritme levert. In de eerdere post over hoe je de beste onderwerpmodellen bouwt, wordt de procedure meer in detail uitgelegd. Ik raad echter aan om de betrokken basisstappen en de interpretatie in het onderstaande voorbeeld te begrijpen.

Stap 0: Laad de nodige pakketten en importeer de stopwoorden.

Step 1: Importeer de dataset. Ik ga de text8 dataset gebruiken die kan worden gedownload met behulp van gensim’s downloader API.

# Step 1: Import the dataset and get the text and real topic of each news articledataset = api.load("text8")data = 

Step 2: Bereid de gedownloade data voor door stopwoorden te verwijderen en het te lemmatiseren. Voor Lemmatization, gensim vereist het pattern pakket. Dus, zorg ervoor dat je pip install pattern in je terminal of prompt doet voordat je dit uitvoert. Ik heb de lemmatisering zo ingesteld dat alleen zelfstandige naamwoorden (NN), bijvoeglijke naamwoorden (JJ) en zelfstandige naamwoorden (RB) worden behouden. Omdat ik er de voorkeur aan geef dat alleen zulke woorden als onderwerp trefwoorden worden gebruikt. Dit is een persoonlijke keuze.

De data_processed wordt nu verwerkt als een lijst van woorden. U kunt dit nu gebruiken om de Dictionary en Corpus te maken, die vervolgens zullen worden gebruikt als invoer voor het LDA-model.

We hebben het woordenboek en het corpus gemaakt. Laten we een LDA topic model bouwen met 7 topics, gebruikmakend van LdaMulticore().

De lda_model.print_topics laat zien welke woorden aan welke van de 7 onderwerpen hebben bijgedragen, samen met het gewicht van de bijdrage van het woord aan dat onderwerp.

Je ziet woorden als ‘ook’, ‘veel’ in verschillende onderwerpen terugkomen. Dus ik zou dergelijke woorden toevoegen aan de stop_words-lijst om ze te verwijderen en het onderwerpmodel verder af te stemmen op het optimale aantal onderwerpen.

LdaMulticore() ondersteunt parallelle verwerking. Je zou ook kunnen proberen welke onderwerpen de LdaModel() geeft.

Hoe interpreteer je de uitvoer van het LDA Topic Model?

Het lda_model object ondersteunt indexering. Dat wil zeggen, als u een document (lijst van woorden) aan de lda_model doorgeeft, levert het 3 dingen:

1. De topic(s) waartoe dat document behoort, samen met percentage.
2. De topic(s) waartoe elk woord in dat document behoort.
3. Het (de) onderwerp(en) waartoe elk woord in dat document behoort EN de phi-waarden.

Wat is de phi-waarde?

De phi-waarde is de waarschijnlijkheid dat het woord tot dat bepaalde onderwerp behoort. En de som van de phi-waarden voor een bepaald woord is gelijk aan het aantal keren dat dat woord in dat document voorkomt.

In de onderstaande uitvoer voor het 0e document bijvoorbeeld, behoort het woord met id=0 tot onderwerp nummer 6 en de phi-waarde is 3,999. Dat betekent dat het woord met id=0 4 keer in het 0e document voorkomt.

Hoe maak je een LSI-onderwerpmodel met behulp van gensim?

De syntaxis voor het gebruik van een LSI-model is vergelijkbaar met hoe we het LDA-model hebben gebouwd, behalve dat we de LsiModel() zullen gebruiken.

Hoe het Word2Vec model te trainen met behulp van gensim?

Een woord inbeddingsmodel is een model dat numerieke vectoren kan leveren voor een gegeven woord. Met behulp van de Gensim’s downloader API, kunt u vooraf gebouwde woord inbeddingsmodellen downloaden, zoals word2vec, fasttext, GloVe en ConceptNet. Deze zijn gebouwd op grote corpussen van veel voorkomende tekst data zoals wikipedia, google news etc.

Als u echter werkt in een gespecialiseerde niche, zoals technische documenten, kan het zijn dat u niet in staat bent om woord inbeddingen voor alle woorden te krijgen. In dergelijke gevallen is het dus wenselijk om uw eigen model te trainen.

Gensim’s Word2Vec implementatie laat u uw eigen woord inbeddingsmodel trainen voor een gegeven corpus.

We hebben een Word2Vec-model getraind en opgeslagen voor ons document. Wanneer er echter een nieuwe dataset komt, wilt u het model bijwerken om rekening te houden met nieuwe woorden.

Hoe werkt u een bestaand Word2Vec-model bij met nieuwe gegevens?

Op een bestaand Word2Vec-model roept u build_vocab() op de nieuwe datset aan en vervolgens roept u de train()-methode op. build_vocab() wordt eerst aangeroepen omdat het model moet weten welke nieuwe woorden het kan verwachten in het binnenkomende corpus.

Hoe kan ik woordvectoren extraheren met vooraf getrainde Word2Vec en FastText modellen?

We hebben zojuist gezien hoe we de woordvectoren kunnen krijgen voor het Word2Vec model dat we zojuist hebben getraind. Met gensim kun je echter de nieuwste vooraf getrainde modellen downloaden via de downloader API. Laten we eens kijken hoe we de woordvectoren uit een paar van deze modellen kunnen halen.

We hebben 3 verschillende inbeddingsmodellen. U kunt evalueren welke beter presteert met behulp van de respectieve model’s evaluate_word_analogies() op een standaard analogieën dataset.

Hoe document vectoren te creëren met behulp van Doc2Vec?

In tegenstelling tot Word2Vec, biedt een Doc2Vec model een gevectoriseerde weergave van een groep woorden die gezamenlijk als een enkele eenheid worden beschouwd. Het is niet een eenvoudig gemiddelde van de woordvectoren van de woorden in de zin.

Laten we de text8 dataset gebruiken om de Doc2Vec te trainen.

import gensimimport gensim.downloader as api# Download datasetdataset = api.load("text8")data = 

De training data voor Doc2Vec moet een lijst van TaggedDocuments zijn. Om er een te maken, geven we een lijst met woorden en een uniek geheel getal als invoer door aan de models.doc2vec.TaggedDocument().

De invoer is voorbereid. Om het model te trainen, moet u het Doc2Vec model initialiseren, de woordenschat opbouwen en tenslotte het model trainen.

Om de documentvector van een zin te krijgen, geeft u deze als een lijst woorden door aan de infer_vector() methode.

Hoe berekent u similariteitsmetrieken zoals cosinus similariteit en zachte cosinus similariteit?

Zachte cosinusgelijkheid is vergelijkbaar met cosinusgelijkheid, maar beschouwt bovendien de semantische relatie tussen de woorden via de vectorrepresentatie.

Om zachte cosinussen te berekenen, hebt u een woordinbeddingsmodel nodig, zoals Word2Vec of FastText. Bereken eerst de similarity_matrix. Converteer dan de ingevoerde zinnen naar een bag-of-words corpus en geef ze door aan de softcossim(), samen met de similariteitsmatrix.

Hieronder staan enkele nuttige similariteits- en afstandsmetrieken, gebaseerd op de woordinbeddingsmodellen zoals FastText en GloVe. We hebben deze modellen al gedownload met behulp van de downloader API.

Hoe kan ik tekstdocumenten samenvatten?

Gensim implementeert de textrank-samenvatting met behulp van de summarize()-functie in de summarization-module. Alles wat u hoeft te doen is de tet string door te geven, samen met ofwel de ratio samenvatting van de uitvoer, ofwel het maximum count aantal woorden in de samengevatte uitvoer.

Het is niet nodig om de zin te splitsen in een tokenized lijst, omdat gensim het splitsen doet met behulp van de ingebouwde split_sentences() methode in de gensim.summarization.texcleaner module.

Laten we het knipsel van een nieuw artikel in sample.txt samenvatten.

Voor meer informatie over samenvatten met gensim, verwijs ik naar deze tutorial.

Conclusie

We hebben veel geleerd over de verschillende mogelijkheden van gensim en krijgen een goede greep op hoe te werken met en het manipuleren van teksten. De bovenstaande voorbeelden zouden als mooie sjablonen moeten dienen om je op weg te helpen en op voort te bouwen voor verschillende NLP taken. Hopelijk vind je het nuttig en voel je je comfortabel om gensim vaker te gebruiken in je NLP projecten.