Como treinar o modelo word2vec usando a biblioteca gensim

O que é incorporação de palavras ?

A incorporação de palavras é um processo de compreensão do texto por algoritmos de aprendizagem de máquina, também dizemos que a incorporação de palavras é uma representação aprendida para o texto onde captura o contexto da palavra num documento, a semelhança semântica e sintáctica, bem como a relação entre outras palavras em corpus.

Esta abordagem contém a chave para resolver os problemas naturais de processamento de linguagem usando a aprendizagem de máquina e algoritmo de aprendizagem profunda. Basicamente, a incorporação de palavras é uma representação vetorial de palavras. Ao calcular a distância ou posição das palavras, ele representa palavras, frases, parágrafos ou documentos.

Até agora foram introduzidas várias técnicas de incorporação de palavras. Geralmente, dizemos que existem dois tipos de incorporação de palavras –

• Integração Estática de Palavras
• Integração Contextual de Palavras

1. Incorporação de palavras estáticas: Métodos tradicionais como Skip-Gram e Continuous Bag-of-Words aprendem a incorporação estática através do treino de tabelas de pesquisa que traduzem palavras em densos vetores. A incorporação estática é directamente útil para resolver tarefas semânticas léxicas.

Problema: Não consegue resolver ambiguidades para palavras polissemáticas. Como quando uma palavra representa múltiplos significados em duas frases diferentes, os métodos Skip-Gram ou BOW falham.

2. Embutir palavras contextuais: A incorporação de palavras contextualizadas visa capturar a semântica de palavras em diferentes contextos para abordar a questão do polissemo e a natureza dependente do contexto das palavras. LSTM, modelo LSTM bidirecional etc. ajuda a obter a forma vetorial das palavras.

Modelo Word2Vec: Word2Vec é um método para construir tal incorporação estática de palavras. Isto foi conseguido usando dois métodos Skip Gram e Common Bag of Words (CBOW) com a ajuda de redes neurais. Ele foi desenvolvido por Tomas Mikolov em 2013 no Google.

Por que precisamos deles?

Vamos dizer que temos frases abaixo.

“Eu adoro codificar em Jupyter” e “Eu gosto de codificar em Pycharm”.

Tuas frases são muito próximas uma da outra. Se construirmos um vocabulário exaustivo (vamos chamar-lhe V), terá V = {I, love, enjoy, coding, in, Jupyter, Pycharm}. Se formos com uma codificação quente. Não conseguiremos obter o significado exato como amor, desfrute, codificando cada palavra estão sendo tratadas como iguais, enquanto amor e desfrute e muito próximos um do outro.

Nosso motivo é ter palavras com contexto semelhante será a posição espacial muito próxima. Matematicamente, a distância co-seno identificará o quão próximas estão duas palavras. A distância cosseno da palavra mais próxima ou cosseno do anjo estará próxima de 0 e para o mais distante estará próxima de 1.

Como funciona o Word2Vec?

O modelo Word2Vec pode rodar em dois algoritmos –

• Skip-grama-5162>
• CBOW (Continuous Bag of Words)

CBOW Model: Este método toma o contexto de cada palavra como a entrada e tenta prever a palavra correspondente ao contexto. No processo de prever a palavra alvo, aprendemos a representação vectorial da palavra alvo. Como input várias palavras estarão lá como por tamanho de janela(5 palavras) mas retornará uma palavra como saída.

Vejamos a arquitetura mais profunda:

>

Modelo de Skip-Gram: Este é outro algoritmo para Word2Vec. É exatamente o oposto do modelo CBOW. O modelo tomará uma palavra como entrada, mas retornará múltiplas palavras como por tamanho de janela.

>

Implementação da palavra Embedding with Gensim Word2Vec Model:

Aqui, explicarei passo a passo como o modelo do Word2vec utiliza o Gensim. Dataset, eu coletei da plataforma Kaggle. Este conjunto de dados foi recolhido de dados públicos do Myers-Briggs Type Indicator. Ele contém duas colunas tipo e post. “type” define 16 tipos de personalidade e “post” define comentários desses 16 tipos de indivíduo personalizado.

1. Carregamento e Descrição dos Dados

# Carregamento do conjunto de dados
data_df = pd.read_csv(“data/mbti_1.csv”)
data_df.head()

2. Limpeza e Pré-processamento de Dados

Após carregar os dados, é necessário encontrar se os dados contêm valor de NA, se o valor de NA dentro do conjunto de dados, vamos largá-lo.

# Removendo valores de NA do quadro de dados
def data_na_value_cleaning(data):
print(“\nBefore cleaning, Data Shape : “, data.shape)
print(“\nAntes de remover valores Nulos: – – – – – – – -“)
print(data.isna().sum())
data.dropna(inplace=True)
data.reset_index(inplace=True,drop=True)
print(“Depois de remover valores Nulos: – – – – – – – – – -“)
print(data.isna().sum())
print(“\nApós limpeza, Data Shape : “, data.shape)
return data

Como nossos dados em não ter nenhum valor de NA. Portanto, nenhuma fila foi removida. Agora, verificamos se existem valores duplicados em Dataset.

# Removendo valores duplicados
def duplicate_content_removal(data, col, ini_row):
print(“\nBem antes de remover duplicados, o número de dados foi: “, ini_row)
duplicate_count = data.duplicated().sum()
print(“\nNúmero de Duplicatas: “, duplicate_count)

description_data = data.drop_duplicates()
cleaned_row = len(description_data)
if (ini_row – cleaned_row) > 0:
print(“\nTotal data reduction : “(ini_row – cleaned_row))
print(“\nApós remover duplicados, o número de dados é :”, cleaned_row)
else:
print(“\nDataset não contém nenhum dado duplicado.”)
lista de retorno(description_data)

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

Agora como parte do processo de limpeza removeremos links e pontuação. Além disso, para um melhor treinamento apenas consideraremos palavras e não palavras numéricas e alfanuméricas. Nós removeremos stopwords para melhor entendimento e precisão do modelo.

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

# removendo tudo excepto as letras a-z inglesas
regex = re.compile(”)
temp_string = regex.sub(‘ ‘, temp_string)

# removendo espaços extra
clean_string = re.sub(‘ +’, ‘ ‘ ‘, temp_string).lower()

return clean_string

Next método data_cleaning

def data_cleaning(content):
sentences =
for idx in tqdm(range(len(content))):
if content !=””:
# Tokenização de frases usando a biblioteca NLTK
para cada_enviado em send_tokenize(str(content)):
se cada_enviado!= “”:
temp_sent =
# Removendo link e pontuação
cada_enviado = remove_link_punc(each_sent.lower())

# Removendo stopwords e aplicando lemmatização
para cada_palavra em cada_enviado.split():
se cada_palavra não estiver em stop_words e len(each_word)>= 3:
temp_sent.append(lemmatizer.lemmatize(each_word))

>

# Apenas o comprimento da lista de palavras é maior do que 5
se len(temp_sent) >= 5:
sentences.append(temp_sent)
sentenças de retorno

sent_corpus = data_cleaning(posts)

>

# Estatísticas das palavras sentenciadas
len_count =
for l in send_corpus:
len_count.append(len(l))

print(“Número total de frases : “, len(len_count))
word_sent_df = pd.DataFrame(sorted(Counter(len_count).items()), columns=)
word_sent_df.head(10)

Após limpeza e pré-processamento de dados, os dados se parecem com cada palavra em um cotão. Cada lista é a representação de uma frase. Genism word2vec requer um formato de ‘lista de listas’ para treinamento onde cada documento está contido em uma lista e cada lista contém listas de fichas daquele documento.

3. Modelo de treinamento

Agora vamos treinar o modelo word2vec usando a biblioteca Gensim com nosso próprio conjunto de dados.

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

sentences : onde podemos passar o nosso conjunto de dados preparado que é send_corpus

size : Dimensão da forma vetorial gerada de cada palavra, por padrão o tamanho é 100.

janela : Distância máxima entre a palavra atual e a prevista dentro de uma frase, o valor padrão é 5

min_count : Ignorar todas as palavras onde a freqüência de cada palavra é menor que min_count, o valor padrão é 5. Como queríamos adicionar todas as palavras no corpus, então o valor fornecido é 1.

workers : Utiliza esses muitos threads para treinar o modelo. O valor padrão é 3.

sg : Usado para escolher o algoritmo de treinamento: 1 para skip-gram; 0 para CBOW. Por padrão CBOW é usado para treinamento.

4. Palavra do formulário vetorial

Após a conclusão do treinamento do modelo. Nós podemos ir para obter a forma vetorial de cada palavra. Existem dois métodos para obter a forma vetorial. A forma vetorial será 200 conforme o tamanho dado.

# Obter a forma vetorial da palavra king
model.wv.get_vector(‘king’)

Or

# Outra forma de obter a forma vetorial da palavra2vec
model.wv.word_vec(‘king’)

5. Similaridade e distância entre duas palavras

Forneceremos duas listas de palavras ‘rei’, ‘macho’ numa lista e ‘rainha’, ‘fêmea’ noutra lista. Vamos tentar descobrir o quanto semelhantes essas duas palavras da lista.

# Lista de similaridade de palavras
model.wv.n_similarity(,)

Aqui vamos olhar, qual é a distância entre duas palavras. Tipo similar de palavras terá menos distância.

# Distância entre duas palavras
model.wv.distância(‘king’,’queen’)

Se quisermos obter semelhantes, então podemos usar abaixo o código.

# Palavra semelhante para king
model.wv.similar_por_palavra(‘king’)

>

6. Outras técnicas usando a palavra2Vec

# Estranha da lista de palavras
model.wv.doesnt_match()

>Isso nos ajudará a encontrar palavras ímpares presentes em uma lista.

# avaliação de pares de palavras
model.wv.evaluation_word_pairs(‘data/SimLex-999/SimLex-999_2.txt’,)

>Isso nos ajudará a avaliar o par de palavras

# analogia de palavras da lista de palavras
model.wv.evaluation_word_analogies(‘data/questions-words.txt’)

Isso será útil para analogia de palavras

7. Carregando modelo treinado

Se precisarmos usar modelo treinado, o que pode ser conseguido usando o código abaixo.

# Carregando o modelo pré-treino do google
de modelos de importação gensim

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

Aqui eu tentei carregar o modelo pré-treino do google. Podemos fazer o download a partir do link. Este modelo também é muito poderoso e treinado em enorme conjunto de dados.

Para mais detalhes sobre a implementação, você pode dar uma olhada no meu código no github.

Pois para leitura, por favor deixe-me se houver alguma dúvida ou questão. Terei o maior prazer em responder às vossas questões.