Prossiga com GloVe Embeddings

Nov 27 2022

Você quer usar os embeddings GloVe em seu projeto? Várias terminologias estão causando problemas? Parabéns! Você está no lugar certo. Observação: este artigo não discute a matemática por trás da incorporação do GloVe.

Foto de Nick Morrison no Unsplash

Você quer usar os embeddings GloVe em seu projeto? Várias terminologias estão causando problemas? Parabéns! Você está no lugar certo.

Observação: este artigo não discute a matemática por trás da incorporação do GloVe.

Neste artigo, aprenderemos como usar os embeddings GloVe para transformar qualquer dado de texto em números. Aprenderemos as etapas usando um corpus de texto curto e, em seguida, aplicaremos essas etapas para obter a incorporação do conjunto de dados de revisão de filmes do IMDB. Usaremos a incorporação obtida para treinar um classificador de sentimento binário no mesmo conjunto de dados.

Vamos começar!

Introdução

Há uma variedade de incorporações de palavras GloVe pré-treinadas disponíveis para download. Mais informações sobre o corpus de treinamento de diferentes incorporações do Glove podem ser encontradas neste site. Neste tutorial, usaremos os embeddings glovetwitter27b50d, que possuem 50 dimensões e foram treinados em tweets 2B do Twitter.

A incorporação está disponível como um arquivo de texto onde cada linha possui uma string contendo uma palavra e sua representação vetorial. Vamos converter o conteúdo deste arquivo de texto em um dicionário.

# Read the text file
glovetwitter27b50d = "pathe_to_glovetwitter27b50d.txt"
file = open(glovetwitter27b50d)
glovetwitter27b50d = file.readlines()


# Convert the text file into a dictionary
def ConvertToEmbeddingDictionary(glovetwitter27b50d):
    embedding_dictionary = {}
    for word_embedding in tqdm(glovetwitter27b50d):
        word_embedding = word_embedding.split()
        word = word_embedding[0]
        embedding = np.array([float(i) for i in word_embedding[1:]])
        embedding_dictionary[word] = embedding
    return embedding_dictionary
embedding_dictionary = ConvertToEmbeddingDictionary(glovetwitter27b50d)

# Let's look at the embedding of the word "hello."
embedding_dictionary['hello']
Output:
array([ 0.28751  ,  0.31323  , -0.29318  ,  0.17199  , -0.69232  ,
       -0.4593   ,  1.3364   ,  0.709    ,  0.12118  ,  0.11476  ,
       -0.48505  , -0.088608 , -3.0154   , -0.54024  , -1.326    ,
        0.39477  ,  0.11755  , -0.17816  , -0.32272  ,  0.21715  ,
        0.043144 , -0.43666  , -0.55857  , -0.47601  , -0.095172 ,
        0.0031934,  0.1192   , -0.23643  ,  1.3234   , -0.45093  ,
       -0.65837  , -0.13865  ,  0.22145  , -0.35806  ,  0.20988  ,
        0.054894 , -0.080322 ,  0.48942  ,  0.19206  ,  0.4556   ,
       -1.642    , -0.83323  , -0.12974  ,  0.96514  , -0.18214  ,
        0.37733  , -0.19622  , -0.12231  , -0.10496  ,  0.45388  ])

sample_corpus = ['The woods are lovely, dark and deep',
                 'But I have promises to keep',   
                 'And miles to go before I sleep', 
                 'And miles to go before I sleep']

# This is the maximum number of tokens we wish to consider from our dataset.
# When there are more tokens, the tokens with the highest frequency are chosen.
max_number_of_words = 5

# Note: Keras tokenizer selects only top n-1 tokens if the num_words is set to n
tokenizer = Tokenizer(num_words=max_number_of_words)
tokenizer.fit_on_texts(sample_corpus)
sample_corpus_tokenized = tokenizer.texts_to_sequences(sample_corpus)
print(tokenizer.word_index)
Output:
{'and': 1, 'i': 2, 'to': 3, 'miles': 4, 'go': 5, 'before': 6, 'sleep': 7, 'the': 8, 'woods': 9, 'are': 10, 'lovely': 11, 'dark': 12, 'deep': 13, 'but': 14, 'have': 15, 'promises': 16, 'keep': 17}
print("But I have promises to keep: ", sample_corpus_tokenized[1])
Output:
But I have promises to keep:  [2, 3]

Agora que escolhemos um conjunto de tokens de nosso corpus de texto, devemos desenvolver uma matriz de incorporação para eles. A matriz de incorporação terá colunas iguais à dimensão da incorporação e linhas iguais ao número de tokens .

# Create embedding matrix
total_number_of_words = min(max_number_of_words, len(tokenizer.word_index))
embedding_matrix = np.zeros((total_number_of_words,50))
for word, i in tokenizer.word_index.items():
    if i >= total_number_of_words: break
    if word in embedding_dictionary.keys():
        embedding_vector = embedding_dictionary[word]
        embedding_matrix[i] = embedding_vector

As redes neurais artificiais e os algoritmos de ML não podem lidar com um comprimento variável de entradas, portanto, precisamos converter as incorporações de cada sequência de entrada em um tamanho fixo. Existem muitas abordagens para fazer isso, mas a mais simples é somar a incorporação de cada token em uma frase e normalizar o vetor.