Hur man tränar word2vec-modellen med gensim-biblioteket

Vad är word embedding?

Word embedding är en process för att förstå texten med hjälp av maskininlärningsalgoritmer.Vi kan också säga att word embedding är en inlärd representation för text där den fångar ordets kontext i ett dokument, semantisk och syntaktisk likhet samt relationen mellan andra ord i korpusen.

Detta tillvägagångssätt är nyckeln till att lösa problem med behandling av naturliga språk med hjälp av maskininlärning och djupinlärningsalgoritmer. I grund och botten är ordinbäddning en vektorrepresentation av ord. Genom att beräkna avståndet eller positionen för orden representerar den betydelsefulla ord, meningar, stycken eller dokument.

Det finns flera tekniker för inbäddning av ord som hittills har introducerats. Generellt sett säger vi att det finns två typer av ordinbäddning –

• Statisk ordinbäddning
• Kontextuell ordinbäddning

1. Statisk inbäddning av ord: Traditionella metoder som Skip-Gram och Continuous Bag-of-Words lär sig statisk inbäddning genom att träna uppslagstabeller som översätter ord till en tät vektor. Statisk inbäddning är direkt användbar för att lösa lexikala semantiska uppgifter.

Problem: Kan inte lösa tvetydigheter för polysemiska ord. När ett ord representerar flera betydelser i två olika meningar misslyckas Skip-Gram- eller BOW-metoderna.

2. Kontextuell inbäddning av ord: Kontextualiserad inbäddning av ord syftar till att fånga ords semantik i olika sammanhang för att lösa problemet med polysemiska ord och ords kontextberoende natur. LSTM, Bi-directional LSTM etc. modell hjälper till att få fram vektorformen av ord.

Word2Vec-modell: Word2Vec-modellen är en metod för att konstruera en sådan statisk inbäddning av ord. Detta har uppnåtts med hjälp av två metoder Skip Gram och Common Bag of Words (CBOW) med hjälp av neurala nätverk. Den utvecklades av Tomas Mikolov 2013 på Google.

Varför behöver vi dem?

Vad sägs om nedanstående meningar:

”Jag älskar att koda i Jupyter.” och ”Jag gillar att koda i Pycharm”.

Båda meningarna ligger mycket nära varandra. Om vi bygger ett uttömmande ordförråd (låt oss kalla det V) kommer det att ha V = {Jag, älskar, tycker om, kodning, i, Jupyter, Pycharm}. Om vi väljer en varm kodning. Vi kommer inte att kunna få den exakta innebörden eftersom love, enjoy, coding varje ord behandlas som samma, medan love och enjoy och mycket nära varandra.

Vårt motiv är att ha ord med liknande kontext kommer att vara mycket nära rumslig position. Matematiskt sett kommer cosinusavståndet att identifiera hur nära två ord är varandra. Närmaste ords cosinusavstånd eller cosinus av ängeln kommer att vara nära 0 och för det mest avlägsna kommer det att vara nära 1.

Hur fungerar Word2Vec?

Word2Vec-modellen kan köras på två algoritmer –

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

CBOW-modellen: Denna metod tar kontexten för varje ord som indata och försöker förutsäga det ord som motsvarar kontexten. I processen att förutsäga målordet lär vi oss vektorrepresentationen av målordet. Som indata kommer flera ord att finnas där enligt fönsterstorlek (5 ord) men det kommer att återge ett ord som utdata.

Låt oss titta djupare på arkitekturen:

Skip-Gram-modell: Denna modell använder sig av en modell som bygger på ett svepande diagram: Detta är en annan algoritm för Word2Vec. Den är raka motsatsen till CBOW-modellen. Modellen tar ett ord som indata, men returnerar flera ord enligt fönsterstorlek.

Implementering av ordinbäddning med Gensim Word2Vec-modell:

Här förklarar jag steg för steg hur man tränar word2vec-modellen med Gensim. Dataset har jag samlat in från Kaggle-plattformen. Detta dataset i från Myers-Briggs Type Indicator offentliga data. Den innehåller två kolumner typ och post. ”type” definierar 16 personlighetstyper och ”post” definierar kommentarer från dessa 16 personlighetstyper.

1. Laddning av data och databeskrivning

# Laddning av datasetet
data_df = pd.read_csv(”data/mbti_1.csv”)
data_df.head()

2. Rengöring och förbehandling av data

När data har laddats måste vi ta reda på om data innehåller NA-värden, om NA-värden finns i datasetet kommer vi att ta bort dem.

# Ta bort NA-värden från dataframe
def data_na_value_cleaning(data):
print(”\nFör rengöring, Data Shape : ”, data.shape)
print(”\nFör att ta bort nollvärden: – – – – – – – – -”)
print(data.isna().sum())
data.dropna(inplace=True)
data.reset_index(inplace=True,drop=True)
print(”Efter att ha tagit bort nollvärden: – – – – – – – – – – -”)
print(data.isna().sum())
print(”\nEfter rensning, Data Shape : ”, data.shape)
return data

Som vår data i inte har några NA värden. Inga rader har därför tagits bort. Nu kontrollerar vi om det finns några dubbla värden i datasetet.

# Ta bort dubbla värden
def duplicate_content_removal(data, col, ini_row):
print(”\nFör att ta bort dubbletter var antalet data : ”, ini_row)
duplicate_count = data.duplicated().sum()
print(”\nAntal dubbletter: ”, duplicate_count)

description_data = data.drop_duplicates()
cleaned_row = len(description_data)
if (ini_row – cleaned_row) > 0:
print(”\nTotal minskning av data : ”, (ini_row – cleaned_row))
print(”\nEfter borttagning av dubbletter är antalet data :”, cleaned_row)
else:
print(”\nDataset innehåller inga dubbletter.”)
return list(description_data)

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

Nu, som en del av rensningsprocessen, kommer vi att ta bort länkar och interpunktion. För bättre utbildning kommer vi också att beakta ord som inte är nummer och alfanumeriska ord. Vi kommer att ta bort stoppord för att förbättra modellens förståelse och noggrannhet.

def remove_link_punc(string):
# tar bort länkar
temp_string = re.sub(’http?://(?:|||(??:%))+’, ’ ’, string)

# tar bort allt utom a-z engelska bokstäver
regex = re.compile(”)
temp_string = regex.sub(’ ’, temp_string)

# tar bort extra blanksteg
clean_string = re.sub(’ +’, ’ ’, temp_string).lower()

return clean_string

Nästa metod data_cleaning

def data_cleaning(content):
sentences =
for idx in tqdm(range(len(content))):
if content !=””:
# Tokenisering av meningar med hjälp av NLTK-biblioteket
for each_sent in sent_tokenize(str(content)):
if each_sent != ””:
temp_sent =
# Ta bort länk och interpunktion
each_sent = remove_link_punc(each_sent.lower())

# Ta bort stoppord och tillämpa lemmatisering
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))

# Endast om längden på ordlistan är större än lika med 5
if len(temp_sent) >= 5:
satser.append(temp_sent)
return sentences

sent_corpus = data_cleaning(posts)

# Statistik över meningsord
len_count =
for l in sent_corpus:
len_count.append(len(l))

print(”Totalt antal meningar : ”, len(len_count))
word_sent_df = pd.DataFrame(sorted(Counter(len_count).items()), columns=)
word_sent_df.head(10)

Efter rensning och förbehandling av data ser data ut som varje ord i en lint. Varje lista är en representation av en mening. Genism word2vec kräver ett format av ”list of lists” för träning där varje dokument ingår i en lista och varje lista innehåller listor med tokens i det dokumentet.

3. Träning av modellen

Nu ska vi träna word2vec-modellen med hjälp av Gensim-biblioteket med vårt eget dataset.

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

sentences : där kan vi skicka vårt förberedda dataset som är sent_corpus

size : dimensionen på den genererade vektorformen för varje ord, som standard är storleken 100.

window : Maximalt avstånd mellan det aktuella och det förutspådda ordet inom en mening, standardvärdet är 5

min_count : Ignorera alla ord där frekvensen av varje ord är mindre än min_count, standardvärdet är 5. Eftersom vi ville lägga till alla ord i korpusen, så är det värde som vi gav 1.

workers : Använder dessa många trådar för att träna modellen. Standardvärdet är 3

sg : Används för att välja träningsalgoritm: 1 för skip-gram; 0 för CBOW. Som standard används CBOW för träning.

4. Vector form word

När modellträningen är klar. Vi kan gå för att få vektoriserad form av varje ord. Det finns två metoder för att få fram vektorformen. Vektorns form blir 200 enligt given storlek.

# Få vektorform av ordet king
model.wv.get_vector(’king’)

Och

# Ett annat sätt att få fram vektoriserad form av ordet2vec
model.wv.word_vec(’king’)

5. Likhet och avstånd mellan två ord

Vi kommer att tillhandahålla två listor med orden ”kung”, ”manlig” i en lista och ”drottning”, ”kvinnlig” i en annan lista. Vi kommer att försöka ta reda på hur lika dessa två ord är.

# Lista över ords likhet
model.wv.n_similarity(,)

Här kommer vi att titta på avståndet mellan två ord.Liknande ord kommer att ha mindre avstånd.

# Avstånd mellan två ord
model.wv.distance(’king’,’queen’)

Om vi vill få fram liknande kan vi använda nedanstående kod.

# Liknande ord för king
model.wv.similar_by_word(’king’)

6. Andra tekniker med hjälp av word2Vec

# Välj ut ett ord från listan över ord
model.wv.doesnt_match()

Detta hjälper oss att hitta udda ord i en lista.

# utvärdering av ordpar
model.wv.evaluate_word_pairs(’data/SimLex-999/SimLex-999_2.txt’,)

Detta hjälper oss att utvärdera ordparen

# Ordanalogi från listan över ord
model.wv.evaluate_word_analogies(’data/questions-words.txt’)

Detta kommer att vara användbart för ordanalogi

7. Laddning av tränad modell

Om vi behöver använda den tränade modellen kan vi använda nedanstående kod.

# Laddar googles förtränade modell
from gensim import models

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

Här försökte jag ladda googles förtränade modell. Vi kan ladda ner från länken. Denna modell är också mycket kraftfull och tränad på enorma dataset.

För mer detaljer om genomförandet kan du ta en titt på min kod på github.

Tack för att du läste, låt mig veta om det finns frågor eller tvivel. Jag svarar gärna på dina frågor.