Maison développement back-end Tutoriel Python Exemple détaillé d'intégration de vecteurs de mots

Exemple détaillé d'intégration de vecteurs de mots

Jun 21, 2017 pm 04:11 PM
vecteur 学习 笔记

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 <unk> 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 = ['<unk>'] + 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!

Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn

Article chaud

Repo: Comment relancer ses coéquipiers
3 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌
R.E.P.O. Crystals d'énergie expliqués et ce qu'ils font (cristal jaune)
1 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌
Combien de temps faut-il pour battre Split Fiction?
3 Il y a quelques semaines By DDD
Hello Kitty Island Adventure: Comment obtenir des graines géantes
3 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌

Article chaud

Repo: Comment relancer ses coéquipiers
3 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌
R.E.P.O. Crystals d'énergie expliqués et ce qu'ils font (cristal jaune)
1 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌
Combien de temps faut-il pour battre Split Fiction?
3 Il y a quelques semaines By DDD
Hello Kitty Island Adventure: Comment obtenir des graines géantes
3 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌

Tags d'article chaud

Bloc-notes++7.3.1

Bloc-notes++7.3.1

Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise

SublimeText3 version chinoise

Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1

Envoyer Studio 13.0.1

Puissant environnement de développement intégré PHP

Dreamweaver CS6

Dreamweaver CS6

Outils de développement Web visuel

SublimeText3 version Mac

SublimeText3 version Mac

Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Comment supprimer les notes Xiaohongshu Comment supprimer les notes Xiaohongshu Mar 21, 2024 pm 08:12 PM

Comment supprimer les notes Xiaohongshu

Que dois-je faire si les notes que j'ai publiées sur Xiaohongshu sont manquantes ? Quelle est la raison pour laquelle les notes qu'il vient d'envoyer sont introuvables ? Que dois-je faire si les notes que j'ai publiées sur Xiaohongshu sont manquantes ? Quelle est la raison pour laquelle les notes qu'il vient d'envoyer sont introuvables ? Mar 21, 2024 pm 09:30 PM

Que dois-je faire si les notes que j'ai publiées sur Xiaohongshu sont manquantes ? Quelle est la raison pour laquelle les notes qu'il vient d'envoyer sont introuvables ?

Comment ajouter des liens de produits dans les notes dans Xiaohongshu Tutoriel sur l'ajout de liens de produits dans les notes dans Xiaohongshu Comment ajouter des liens de produits dans les notes dans Xiaohongshu Tutoriel sur l'ajout de liens de produits dans les notes dans Xiaohongshu Mar 12, 2024 am 10:40 AM

Comment ajouter des liens de produits dans les notes dans Xiaohongshu Tutoriel sur l'ajout de liens de produits dans les notes dans Xiaohongshu

Apprenez à désinstaller complètement pip et à utiliser Python plus efficacement Apprenez à désinstaller complètement pip et à utiliser Python plus efficacement Jan 16, 2024 am 09:01 AM

Apprenez à désinstaller complètement pip et à utiliser Python plus efficacement

Une plongée approfondie dans la palette de couleurs de matplotlib Une plongée approfondie dans la palette de couleurs de matplotlib Jan 09, 2024 pm 03:51 PM

Une plongée approfondie dans la palette de couleurs de matplotlib

Révéler l'attrait du langage C : découvrir le potentiel des programmeurs Révéler l'attrait du langage C : découvrir le potentiel des programmeurs Feb 24, 2024 pm 11:21 PM

Révéler l'attrait du langage C : découvrir le potentiel des programmeurs

Premiers pas avec Pygame : didacticiel complet d'installation et de configuration Premiers pas avec Pygame : didacticiel complet d'installation et de configuration Feb 19, 2024 pm 10:10 PM

Premiers pas avec Pygame : didacticiel complet d'installation et de configuration

Comment publier un tutoriel de notes sur Xiaohongshu ? Peut-il bloquer les gens en publiant des notes ? Comment publier un tutoriel de notes sur Xiaohongshu ? Peut-il bloquer les gens en publiant des notes ? Mar 25, 2024 pm 03:20 PM

Comment publier un tutoriel de notes sur Xiaohongshu ? Peut-il bloquer les gens en publiant des notes ?

See all articles