web-dev-qa-db-fra.com

Utilisation de l'incorporation de gensim Word2vec pré-formée dans les kéros

J'ai formé Word2vec à Gensim. Dans Keras, je veux l'utiliser pour créer une matrice de phrase en utilisant cette intégration de Word. Comme stocker la matrice de toutes les phrases est très peu d'espace et de mémoire. Donc, je veux créer une couche d'intégration dans Keras pour y parvenir afin qu'elle puisse être utilisée dans d'autres couches (LSTM). Pouvez-vous me dire en détail comment procéder?

PS: C'est différent des autres questions car j'utilise gensim pour la formation Word2vec au lieu des keras.

pythonkerasgensimword2vecword-embedding
6
shivank01

Disons que vous avez les données suivantes que vous devez encoder

docs = ['Well done!',
        'Good work',
        'Great effort',
        'Nice work',
        'Excellent!',
        'Weak',
        'Poor effort!',
        'not good',
        'poor work',
        'Could have done better.']

Vous devez ensuite le tokeniser en utilisant le Tokenizer de Keras comme ceci et trouver le vocab_size

t = Tokenizer()
t.fit_on_texts(docs)
vocab_size = len(t.Word_index) + 1

Vous pouvez ensuite l'appliquer à des séquences comme celle-ci

encoded_docs = t.texts_to_sequences(docs)
print(encoded_docs)

Vous pouvez ensuite remplir les séquences de sorte que toutes les séquences soient de longueur fixe

max_length = 4
padded_docs = pad_sequences(encoded_docs, maxlen=max_length, padding='post')

Utilisez ensuite le modèle Word2vec pour créer une matrice d'intégration

# load embedding as a dict
def load_embedding(filename):
    # load embedding into memory, skip first line
    file = open(filename,'r')
    lines = file.readlines()[1:]
    file.close()
    # create a map of words to vectors
    embedding = dict()
    for line in lines:
        parts = line.split()
        # key is string Word, value is numpy array for vector
        embedding[parts[0]] = asarray(parts[1:], dtype='float32')
    return embedding

# create a weight matrix for the Embedding layer from a loaded embedding
def get_weight_matrix(embedding, vocab):
    # total vocabulary size plus 0 for unknown words
    vocab_size = len(vocab) + 1
    # define weight matrix dimensions with all 0
    weight_matrix = zeros((vocab_size, 100))
    # step vocab, store vectors using the Tokenizer's integer mapping
    for Word, i in vocab.items():
        weight_matrix[i] = embedding.get(Word)
    return weight_matrix

# load embedding from file
raw_embedding = load_embedding('embedding_Word2vec.txt')
# get vectors in the right order
embedding_vectors = get_weight_matrix(raw_embedding, t.Word_index)

Une fois que vous avez la matrice d'intégration, vous pouvez l'utiliser dans la couche Embedding comme ceci

e = Embedding(vocab_size, 100, weights=[embedding_vectors], input_length=4, trainable=False)

Cette couche peut être utilisée pour créer un modèle comme celui-ci

model = Sequential()
e = Embedding(vocab_size, 100, weights=[embedding_matrix], input_length=4, trainable=False)
model.add(e)
model.add(Flatten())
model.add(Dense(1, activation='sigmoid'))
# compile the model
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc'])
# summarize the model
print(model.summary())
# fit the model
model.fit(padded_docs, labels, epochs=50, verbose=0)

Tous les codes sont adaptés de this article de blog génial. suivez-le pour en savoir plus sur les intégrations avec Glove

Pour utiliser Word2vec, voir this post

10
Sreeram TP

Avec la nouvelle version Gensim, c'est assez simple:

w2v_model.wv.get_keras_embedding(train_embeddings=False)

là, vous avez votre couche d'intégration Keras

7
Sebastian J. Vogt

Mon code pour le modèle w2v formé par gensim. Supposons que tous les mots formés dans le modèle w2v sont maintenant une variable de liste appelée all_words.

from keras.preprocessing.text import Tokenizer
import gensim
import pandas as pd
import numpy as np
from itertools import chain

w2v = gensim.models.Word2Vec.load("models/w2v.model")
vocab = w2v.wv.vocab    
t = Tokenizer()

vocab_size = len(all_words) + 1
t.fit_on_texts(all_words)

def get_weight_matrix():
    # define weight matrix dimensions with all 0
    weight_matrix = np.zeros((vocab_size, w2v.vector_size))
    # step vocab, store vectors using the Tokenizer's integer mapping
    for i in range(len(all_words)):
        weight_matrix[i + 1] = w2v[all_words[i]]
    return weight_matrix

embedding_vectors = get_weight_matrix()
emb_layer = Embedding(vocab_size, output_dim=w2v.vector_size, weights=[embedding_vectors], input_length=FIXED_LENGTH, trainable=False)
0
Zack Light