Exemple détaillé d'intégration de vecteurs de mots-Tutoriel Python-php.cn

L'intégration de vecteurs de mots nécessite un traitement efficace de corpus de textes à grande échelle. mot2vec. De manière simple, le mot est envoyé au système d'apprentissage de codage one-hot, la longueur est un vecteur de la longueur du vocabulaire, l'élément de position correspondant du mot est 1 et les autres éléments sont 0. La dimension vectorielle est très élevée et ne peut décrire l’association sémantique de différents mots. La cooccurrence représente les mots, résout les associations sémantiques, parcourt un corpus de texte à grande échelle, compte les mots environnants à une certaine distance de chaque mot et représente chaque mot avec le nombre normalisé de mots proches. Les mots dans des contextes similaires ont une sémantique similaire. Utilisez PCA ou des méthodes similaires pour réduire la dimensionnalité du vecteur d'occurrence afin d'obtenir une représentation plus dense. Il a de bonnes performances et suit toutes les matrices de cooccurrence du vocabulaire. La largeur et la hauteur correspondent à la longueur du vocabulaire. En 2013, Mikolov, Tomas et d'autres ont proposé une méthode de représentation des mots par calcul contextuel, « Estimation efficace des représentations de mots dans l'espace vectoriel » (préimpression arXiv arXiv : 1301.3781 (2013)). Le modèle skip-gram part d'une représentation aléatoire et prédit un simple classificateur de mots contextuels basé sur le mot actuel. L'erreur se propage à travers le poids du classificateur et la représentation du mot, et les deux sont ajustés pour réduire l'erreur de prédiction. Le vecteur de représentation du modèle de formation de corpus à grande échelle se rapproche du vecteur de cooccurrence compressé.

Ensemble de données, le fichier de dump Wikipedia anglais contient l'historique complet des révisions de toutes les pages, la version actuelle de la page est de 100 Go.

Téléchargez le fichier dump et extrayez les mots de la page. Comptez le nombre d'occurrences de mots et construisez une liste de vocabulaire commune. Encodez les pages extraites à l’aide d’un vocabulaire. Le fichier est lu ligne par ligne et les résultats sont immédiatement écrits sur le disque. Enregistrez les points de contrôle entre les différentes étapes pour éviter les plantages du programme.

__iter__ parcourt la page de liste d'index de mots. encode obtient l'index de vocabulaire du mot chaîne. decode renvoie le mot chaîne en fonction de l'index du vocabulaire. _read_pages extrait les mots d'un fichier de vidage Wikipédia (XML compressé) et les enregistre dans un fichier pages, avec une ligne de mots séparés par des espaces par page. La fonction d'ouverture du module bz2 lit les fichiers. Traitement de compression des résultats intermédiaires. Les expressions régulières capturent toute séquence de lettres consécutives ou de lettres spéciales individuelles. _build_vocabulary compte le nombre de mots dans le fichier d'échange et les mots à haute fréquence sont écrits dans le fichier. L'encodage à chaud nécessite un vocabulaire. Encodage d’index de glossaire. Les fautes d'orthographe et les mots extrêmement rares sont supprimés et le vocabulaire ne contient que vocabulaire_size - 1 mots les plus courants. Tous les mots qui ne font pas partie du vocabulaire sont marqués et n'apparaissent pas dans les vecteurs de mots.

Formez dynamiquement des échantillons d'entraînement, organisez une grande quantité de données et le classificateur n'occupe pas beaucoup de mémoire. Le modèle skip-gram prédit les mots contextuels du mot actuel. Parcourez le texte, les données de mots actuelles, les mots cibles environnants et créez des échantillons d'entraînement. Taille du contexte R, chaque mot génère 2R échantillons, R mots à gauche et à droite du mot courant. Le contexte sémantique, la distance proche est important, créez le moins d'échantillons d'entraînement de mots en contexte lointain possible et sélectionnez au hasard la taille du contexte du mot dans la plage [1, D = 10]. Les paires d'entraînement sont formées sur la base du modèle skip-gram. Les tableaux Numpy génèrent des données par lots de flux numériques.

Initialement, les mots sont représentés comme des vecteurs aléatoires. Le classificateur prédit la représentation actuelle du mot contextuel sur la base de la représentation de niveau intermédiaire. Propager les erreurs, affiner les poids et saisir les représentations de mots. Optimisation du modèle MomentumOptimizer, manque d'intelligence et haute efficacité.

Le classificateur est le cœur du modèle. La perte d'estimation contrastée du bruit présente d'excellentes performances. Modélisation du classificateur Softmax. tf.nn.nce_loss Nouvel échantillon négatif vectoriel aléatoire (échantillon de comparaison), classificateur softmax approximatif.

Le modèle de formation est terminé et le vecteur de mot final est écrit dans le fichier. Un sous-ensemble du corpus Wikipédia a été formé sur un processeur normal pendant 5 heures, et la représentation d'intégration du tableau NumPy a été obtenue. Corpus complet : . La classe AttrDict est équivalente à un dict Python, avec des clés accessibles sous forme d'attributs.

import bz2
import collections
import os
import re
from lxml import etree
from helpers import download
class Wikipedia :
TOKEN_REGEX = re.compile(r '[A-Za-z]+|[!?.:,()]')
def __init__(self, url, cache_dir, vocabulaire_size=10000):
self._cache_dir = os.path.expanduser (cache_dir)
self._pages_path = os.path.join(self._cache_dir, 'pages.bz2')
self._vocabulary_path = os.path.join(self._cache_dir, 'vocabulary.bz2')
   if not os.path.isfile(self._pages_path):
print('Read pages')
self._read_pages(url)
if not os.path.isfile(self._ chemin_vocabulaire) :
print('Build vocabulaire')
self._build_vocabulary(vocabulary_size)
avec bz2.open(self._vocabulary_path, 'rt') comme vocabulaire :
   print('Lire le vocabulaire')
self._vocabulary = [x.strip() pour x dans le vocabulaire]
self._indices = {x : i pour i, x in enumerate(self._vocabulary)}
def __iter__(self):
avec bz2.open(self._pages_path, 'rt') comme pages :
pour la page dans les pages :
   mots = [self.encode(x ) pour x dans les mots]
   rendez des mots
@property
def vocabulaire_size(self):
return len(self._vocabulary)
def encode(self, word):
retour self._indices.get(word, 0)
def decode(self, index):
return self._vocabulary[index]
def _read_pages(self, url):
wikipedia_path = download(url , self._cache_dir)
avec bz2.open(wikipedia_path) comme wikipedia,
bz2.open(self._pages_path, 'wt') comme pages :
pour _, élément dans etree.iterpars e(wikipédia, tag='{*}page'):
si element.find('./{*}redirect') n'est pas Aucun :
   continuer
page = } revision/{*}text')
   words = self._tokenize(page)
pages.write(' '.join(words) + 'n')
element.clear() déf _build_vocabulary(self, vocabulaire_size):
counter = collections.Counter()
avec bz2.open(self._pages_path, 'rt') en tant que pages :
pour une page dans des pages :
   mots = page .strip().split()
counter.update(words)
common = [''] + counter.most_common(vocabulary_size - 1)
common = [x[0] pour x en commun]
avec bz2.open(self._vocabulary_path, 'wt') comme vocabulaire :
pour le mot en commun :
vocabulaire.write(word + 'n')
@ méthode de classe
def _tokenize(cls, page):
words = cls.TOKEN_REGEX.findall(page)
   words = [x.lower() pour x dans les mots]
retourner les mots

importer tensorflow as tf
import numpy as np
from helpers import lazy_property
class EmbeddingModel:
def __init__(self, data, target, params):
self.data = data
   moi-même. target = target
self.params = params
self.embeddings
self.cost
self.optimize
@lazy_property
   def embeddings(self):
initial = tf. random_uniform(
[self.params.vocabulary_size, self.params.embedding_size],
-1.0, 1.0)
return tf.Variable(initial)
   @lazy_property
def optimiser (auto) :
optimiseur = tf.train.MomentumOptimizer(
self.params.learning_rate, self.params.momentum)
return optimizer.minimize(self.cost)
@lazy_property
coût définitif ( self):
   embedded = tf.nn.embedding_lookup(self.embeddings, self.data)
weight = tf.Variable(tf.truncated_normal(
[self.params.vocabulary_size, self.params.embedding _taille ],
stddev=1.0 / self.params.embedding_size ** 0.5))
biais = tf.Variable(tf.zeros([self.params.vocabulary_size]))
target = s'assombrit ( self.target, 1)
return tf.reduce_mean(tf.nn.nce_loss(
poids, biais, intégré, cible,
self.params.contrastive_examples,
   self.params.vocabulary_size))

importer des collections
importer tensorflow en tant que tf
importer numpy en tant que np
à partir de lots d'importation par lots
depuis EmbeddingModel importer EmbeddingModel
depuis skipgrams importer des skipgrams
depuis Wikipédia importer Wikipédia
from helpers import AttrDict
WIKI_DOWNLOAD_DIR = './wikipedia'
params = AttrDict(
embedding_size=200,
contrastive_examples=100,
learning_rate=0.5,
momentum=0.5,
batch_size=1000,
)
data = tf.placeholder(tf.int32, [Aucun])
target = tf.placeholder( tf.int32, [Aucun])
model = EmbeddingModel(data, target, params)
corpus = Wikipedia(
'https://dumps.wikimedia.org/enwiki/20160501/'
'enwiki-20160501-pages-meta-current1.xml-p000000010p000030303.bz2',
WIKI_DOWNLOAD_DIR,
params.vocabulary_size)
examples = skipgrams(corpus, params.max_context)
batches = batched( exemples, params.batch_size)
sess = tf.Session()
sess.run(tf.initialize_all_variables())
average = collections.deque(maxlen=100)
pour l'index, batch in enumerate(batches):
feed_dict = {data: batch[0], target: batch[1]}
cost, _ = sess.run([model.cost, model.optimize], feed_dict)
moyenne.append(cost)
print('{}: {:5.1f}'.format(index + 1, sum(average) / len(average)))
if index > 100000 :
break
embeddings = sess.run(model.embeddings)
np.save(WIKI_DOWNLOAD_DIR + '/embeddings.npy', embeddings)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!