Hoe word2vec model te trainen met behulp van gensim bibliotheek

Wat is woord inbedding ?

Woord inbedding is een proces van het begrijpen van de tekst door machine learning algoritmen, ook zeggen we woord inbedding is een geleerde representatie voor tekst waar het vastleggen van de context van het woord in een document, semantische en syntactische gelijkenis, alsmede de relatie tussen andere woorden in corpus.

Deze benadering houdt de sleutel tot het oplossen van de natuurlijke taalverwerking problemen met behulp van machine leren en diep leren algoritme. In principe, woord inbedding is een vector vertegenwoordiging van woorden. Door het berekenen van de afstand of positie van woorden, het vertegenwoordigt betekenis woorden, zinnen, alinea’s of documenten.

Er zijn verschillende technieken van woord inbedding is tot nu toe geïntroduceerd. In het algemeen zeggen we dat er twee soorten woord inbedding –

• Static Word Embedding
• Contextual Word Embedding

1. Static Word Embedding: Traditionele methoden zoals Skip-Gram en Continuous Bag-of-Words leren statische inbedding door lookup tables te trainen die woorden vertalen in een dichte vector. Statische inbedding zijn direct nuttig voor het oplossen van lexicale semantiek taak.

Probleem: Kan niet oplossen ambiguïteiten voor polysemous woorden. Zoals wanneer een woord vertegenwoordigt meerdere betekenis in twee verschillende zinnen dan Skip-Gram of BOW methoden krijgen mislukt.

2. Contextual Word Embedding: Contextueel woord inbedding heeft als doel het vastleggen van woord semantiek in verschillende contexten om het probleem van polysemous en de context-afhankelijke aard van woorden aan te pakken. LSTM, Bi-directionele LSTM etc model helpt bij het verkrijgen van de vector vorm van woorden.

Word2Vec Model: Word2Vec is een methode om een dergelijke statische woord inbedding te construeren. Dit is bereikt met behulp van twee methoden Skip Gram en Common Bag of Words (CBOW) met behulp van neurale netwerken. Het is ontwikkeld door Tomas Mikolov in 2013 bij Google.

Waarom hebben we ze nodig?

Laten we zeggen dat we onderstaande zinnen hebben.

“Ik hou van coderen in Jupyter.” en “Ik hou van coderen in Pycharm”.

Beide zinnen liggen heel dicht bij elkaar. Als we een uitputtend vocabulaire bouwen (laten we het V noemen), zal het V = {I, love, enjoy, coding, in, Jupyter, Pycharm} hebben. Als we gaan met een hete codering. We zullen niet in staat zijn om de exacte betekenis te krijgen als liefde, genieten, codering elk woord worden behandeld als hetzelfde, terwijl liefde en genieten en zeer dicht bij elkaar.

Ons motief is om woorden met vergelijkbare context zal zeer dicht ruimtelijke positie. Wiskundig gezien, zal de cosinus afstand identificeren hoe dicht twee woorden zijn. De cosinusafstand van het dichtstbijzijnde woord of de cosinus van de engel ligt dicht bij 0 en die van het verst verwijderde woord dicht bij 1.

Hoe werkt Word2Vec?

Word2Vec model kan draaien op twee algoritme –

• Skip-gram
• CBOW (Continuous Bag of Words)

CBOW Model: Deze methode neemt de context van elk woord als invoer en probeert het woord te voorspellen dat met de context overeenkomt. In het proces van het voorspellen van het doelwoord, leren we de vector representatie van het doelwoord. Als invoer zullen er meerdere woorden zijn volgens de venstergrootte (5 woorden), maar het zal één woord teruggeven als uitvoer.

Laten we eens dieper kijken naar de architectuur:

Skip-Gram model: Dit is een ander algoritme voor Word2Vec. Het is het tegenovergestelde van het CBOW-model. Het model neemt één woord als invoer, maar geeft meerdere woorden per venstergrootte.

Implementatie van woordinbedding met Gensim Word2Vec-model:

Hier zal ik stap voor stap uitleggen hoe u word2vec-model traint met Gensim. Dataset, heb ik verzameld van Kaggle platform. Deze dataset in van Myers-Briggs Type Indicator openbare gegevens. Het bevat twee kolommen type en post. “Type” definieert 16 type van persoonlijkheid en “post” definieert commentaar van die 16 types van gepersonaliseerde individual.

1. Gegevens laden en gegevens beschrijven

# De dataset laden
data_df = pd.read_csv(“data/mbti_1.csv”)
data_df.head()

2. Gegevens opschonen en voorbewerken

Na het laden van de gegevens moeten we nagaan of de gegevens NA-waarden bevatten. Als de gegevens NA-waarden bevatten, verwijderen we die.

# Verwijderen van NA-waarden uit dataframe
def data_na_value_cleaning(data):
print(“Vóór het opschonen, gegevensvorm : “, data.shape)
print(“Vóór het verwijderen van Null-waarden: – – – – – -“)
print(data.isna().sum())
data.dropna(inplace=True)
data.reset_index(inplace=True,drop=True)
print(“Na het verwijderen van Null-waarden: – – – – – -“)
print(data.isna().sum())
print(“Na opschonen, gegevensvorm : “, data.shape)
return data

Aangezien onze gegevens geen NA-waarden bevatten. Er zijn dus geen rijen verwijderd. Nu controleren we of er dubbele waarden zijn in de dataset.

# Dubbele waarden verwijderen
def duplicate_content_removal(data, col, ini_row):
print(“Vóór het verwijderen van duplicaten was het aantal gegevens : “, ini_row)
duplicate_count = data.duplicated().sum()
print(“Aantal duplicaten: “, duplicate_count)

description_data = data.drop_duplicates()
opgeschoonde_rij = len(description_data)
indien (ini_row – opgeschoonde_rij) > 0:
print(“\nTotale gegevensvermindering : “, (ini_rij – opgeschoonde_rij))
print(“Na verwijdering van dubbelen, aantal gegevens is :”, opgeschoonde_rij)
else:
print(“Dataset bevat geen dubbele gegevens.”)
return list(description_data)

posts = duplicate_content_removal(data_df, ‘posts’, data_df.shape)

Nu zullen we als onderdeel van het opschoonproces links en interpunctie verwijderen. Ook zullen we, voor een betere training, alleen woorden beschouwen die geen nummer of alfanumerieke woorden zijn. We zullen stopwoorden verwijderen voor een beter begrip en nauwkeurigheid van het model.

def remove_link_punc(string):
# links verwijderen
temp_string = re.sub(‘http?://(?:||(?:%))+’, ‘ ‘, string)

# alles verwijderen behalve a-z engelse letters
regex = re.compile(”)
temp_string = regex.sub(‘ ‘, temp_string)

# extra spaties verwijderen
clean_string = re.sub(‘ +’, ‘ ‘, temp_string).lower()

return clean_string

Volgende methode data_cleaning

def data_cleaning(content):
sentences =
for idx in tqdm(range(len(content)):
if content !=””:
# Tokenisatie van zinnen met behulp van NLTK-bibliotheek
for each_sent in sent_tokenize(str(content)):
if each_sent != “”:
temp_sent =
# Verwijderen van link en interpunctie
each_sent = remove_link_punc(each_sent.lower())

Het verwijderen van stopwoorden en toepassen van lemmatization
for each_word in each_sent.split():
if each_word not in stop_words and len(each_word)>= 3:
temp_sent.append(lemmatizer.lemmatize(each_word))

# Alleen woordlijstlengte groter dan gelijk aan 5 nemen
if len(temp_sent) >= 5:
sentces.append(temp_sent)
return sentences

sent_corpus = data_cleaning(posts)

# Zin woorden stats
len_count =
for l in sent_corpus:
len_count.append(len(l))

print(“Totaal aantal zinnen : “, len(len_count))
word_sent_df = pd.DataFrame(sorted(Counter(len_count).items()), columns=)
word_sent_df.head(10)

Na het opschonen en voorbewerken van de gegevens, zien de gegevens eruit als elk woord in een lint. Elke lijst is een representatie van een zin. Genism word2vec vereist dat een formaat van “lijst van lijsten” voor opleiding waar elk document is opgenomen in een lijst en elke lijst bevat lijsten van tokens van dat document.

3. Model Training

Nu gaan we word2vec model trainen met behulp van Gensim bibliotheek met onze eigen dataset.

model = Word2Vec(sentences=sent_corpus, size=200, window=4, min_count=1, workers=4)

sentences : hier kunnen we onze voorbereide dataset doorgeven die sent_corpus is

size : dimensie van de gegenereerde vectorvorm van elk woord, standaard is de grootte 100.

window : Maximale afstand tussen het huidige en het voorspelde woord binnen een zin, standaardwaarde is 5

min_count : Negeer alle woorden waarvan de frequentie van elk woord lager is dan min_count, standaardwaarde is 5. Aangezien we alle woorden in het corpus wilden toevoegen, hebben we een waarde van 1 opgegeven.

workers : Gebruikt zoveel threads als nodig om het model te trainen. Standaardwaarde is 3

sg : Wordt gebruikt om het trainingsalgoritme te kiezen: 1 voor skip-gram; 0 voor CBOW. Standaard wordt CBOW gebruikt voor training.

4. Vectorvorm woord

Nadat de modeltraining is voltooid. We kunnen gaan om gevectoriseerde vorm van elk woord te krijgen. Er zijn twee methoden om de vector vorm te krijgen. De vorm van de vector zal 200 zijn volgens de gegeven grootte.

# Krijg vectorvorm van woord koning
model.wv.get_vector(‘king’)

Or

# Een andere manier om vectorvorm van woord te krijgen2vec
model.wv.word_vec(‘king’)

5. Gelijkenis en afstand tussen twee woorden

We geven twee lijsten met woorden ‘koning’,’mannelijk’ in de ene lijst en ‘koningin’,’vrouwelijk’ in de andere lijst. We zullen proberen uit te vinden hoeveel die twee lijstwoorden op elkaar lijken.

# Lijst van woordgelijkenis
model.wv.n_similarity(,)

Hier zullen we kijken, wat is de afstand tussen twee woorden.Soortgelijke woorden zullen minder afstand hebben.

# Afstand tussen twee woorden
model.wv.distance(‘king’,’queen’)

Als we gelijksoortige woorden willen krijgen, kunnen we onderstaande code gebruiken.

# Gelijksoortig woord voor koning
model.wv.similar_by_word(‘king’)

6. Andere technieken met behulp van word2Vec

# Kies er een uit de lijst van woorden
model.wv.doesnt_match()

Dit helpt ons om vreemde woorden in een lijst te vinden.

# Evaluatie woordparen
model.wv.evaluate_word_pairs(‘data/SimLex-999/SimLex-999_2.txt’,)

Dit zal ons helpen om het woordpaar te evalueren

# Woordanalogie uit lijst van woorden
model.wv.evaluate_word_analogies(‘data/questions-words.txt’)

Dit zal nuttig zijn voor woordanalogie

7. Opgeleid model laden

Als we het opgeleide model moeten gebruiken, kan dat met onderstaande code worden bereikt.

# Voorgetraind model van google laden
from gensim import models

models.KeyedVectors.load_word2vec_format(‘data/GoogleNews-vectors-negative300.bin’, binary=True)

Hier heb ik geprobeerd om het voorgetrainde model van google te laden. We kunnen downloaden van link. Dit model is ook zeer krachtig en getraind op enorme dataset.

Voor meer details over de uitvoering, kunt u een kijkje nemen op mijn code op github.

Dank voor het lezen, laat het me weten als vraag of twijfel is er. Ik zal blij zijn om uw vragen te beantwoorden.