Detailliertes Beispiel für die Einbettung von Wortvektoren

Die Einbettung von Wortvektoren erfordert eine effiziente Verarbeitung großer Textkorpora. word2vec. Auf einfache Weise wird das Wort an das One-Hot-Codierungs-Lernsystem gesendet, die Länge ist ein Vektor der Länge des Vokabulars, das entsprechende Positionselement des Wortes ist 1 und die anderen Elemente sind 0. Die Vektordimension ist sehr hoch und kann die semantische Assoziation verschiedener Wörter nicht beschreiben. Kookkurrenz stellt Wörter dar, löst semantische Assoziationen auf, durchläuft einen großen Textkorpus, zählt die umgebenden Wörter innerhalb eines bestimmten Abstands zu jedem Wort und stellt jedes Wort mit der normalisierten Anzahl benachbarter Wörter dar. Wörter in ähnlichen Kontexten haben eine ähnliche Semantik. Verwenden Sie PCA oder ähnliche Methoden, um die Dimensionalität des Vorkommensvektors zu reduzieren und eine dichtere Darstellung zu erhalten. Es bietet eine gute Leistung und verfolgt alle Matrizen für das gemeinsame Vorkommen von Vokabeln. Die Breite und Höhe entsprechen der Vokabellänge. Im Jahr 2013 schlugen Mikolov, Tomas und andere eine Methode zur Kontextberechnung der Wortdarstellung vor: „Effiziente Schätzung von Wortdarstellungen im Vektorraum“ (arXiv-Vorabdruck arXiv:1301.3781(2013)). Das Skip-Gramm-Modell geht von einer Zufallsdarstellung aus und sagt einen einfachen Klassifikator von Kontextwörtern basierend auf dem aktuellen Wort voraus. Der Fehler wird durch die Klassifikatorgewichtung und die Wortdarstellung verbreitet und die beiden werden angepasst, um den Vorhersagefehler zu reduzieren. Der Darstellungsvektor des groß angelegten Korpus-Trainingsmodells nähert sich dem komprimierten Kookkurrenzvektor an.

Datensatz, englische Wikipedia-Dump-Datei enthält den vollständigen Revisionsverlauf aller Seiten, die aktuelle Seitenversion ist 100 GB.

Laden Sie die Dump-Datei herunter und extrahieren Sie die Seitenwörter. Zählen Sie die Häufigkeit des Vorkommens von Wörtern und erstellen Sie eine gemeinsame Vokabelliste. Kodieren Sie die extrahierten Seiten mithilfe eines Vokabulars. Die Datei wird Zeile für Zeile gelesen und die Ergebnisse sofort auf die Festplatte geschrieben. Speichern Sie Prüfpunkte zwischen verschiedenen Schritten, um Programmabstürze zu vermeiden.

__iter__ durchläuft die Wortindexlistenseite. encode ruft den Vokabularindex des Stringworts ab. decode gibt das Zeichenfolgenwort gemäß dem Vokabularindex zurück. _read_pages extrahiert Wörter aus einer Wikipedia-Dump-Datei (komprimiertes XML) und speichert sie in einer Seitendatei mit einer Zeile mit durch Leerzeichen getrennten Wörtern pro Seite. Die Öffnungsfunktion des bz2-Moduls liest Dateien. Komprimierungsverarbeitung für Zwischenergebnisse. Reguläre Ausdrücke erfassen eine beliebige Folge aufeinanderfolgender Buchstaben oder einzelne Sonderbuchstaben. _build_vocabulary zählt die Anzahl der Wörter in der Auslagerungsdatei und Wörter mit hoher Häufigkeit werden in die Datei geschrieben. One-Hot-Codierung erfordert ein Vokabular. Kodierung des Glossarindex. Rechtschreibfehler und äußerst ungewöhnliche Wörter werden entfernt und der Wortschatz enthält nur vocabulary_size – 1 der häufigsten Wörter. Alle Wörter, die nicht im Wortschatz vorkommen, sind mit gekennzeichnet und erscheinen nicht in Wortvektoren.

Bilden Sie dynamisch Trainingsmuster, organisieren Sie große Datenmengen und der Klassifikator belegt nicht viel Speicher. Das Skip-Gramm-Modell sagt die Kontextwörter des aktuellen Wortes voraus. Durchlaufen Sie den Text, aktuelle Wortdaten und umgebende Wortziele und erstellen Sie Trainingsbeispiele. Kontextgröße R, jedes Wort generiert 2R Stichproben, R Wörter links und rechts vom aktuellen Wort. Semantischer Kontext, enge Distanz ist wichtig, erstellen Sie so wenige Trainingsbeispiele von Wörtern mit entferntem Kontext wie möglich und wählen Sie die Wortkontextgröße zufällig im Bereich [1, D = 10] aus. Trainingspaare werden auf Basis des Skip-Gramm-Modells gebildet. Numpy-Arrays generieren numerische Stream-Batch-Daten.

Zunächst werden Wörter als Zufallsvektoren dargestellt. Der Klassifikator sagt die aktuelle Darstellung des Kontextworts basierend auf der Darstellung auf mittlerer Ebene voraus. Verbreiten Sie Fehler, optimieren Sie Gewichtungen und geben Sie Wortdarstellungen ein. MomentumOptimizer-Modelloptimierung, mangelnde Intelligenz und hohe Effizienz.

Der Klassifikator ist der Kern des Modells. Der Kontrastschätzungsverlust des Rauschens weist eine hervorragende Leistung auf. Modellierung des Softmax-Klassifikators. tf.nn.nce_loss Neue zufällige vektornegative Stichprobe (Vergleichsstichprobe), ungefährer Softmax-Klassifikator.

Das Trainingsmodell ist abgeschlossen und der endgültige Wortvektor wird in die Datei geschrieben. Eine Teilmenge des Wikipedia-Korpus wurde 5 Stunden lang auf einer normalen CPU trainiert und die Einbettungsdarstellung des NumPy-Arrays erhalten. Vollständiger Korpus: . Die AttrDict-Klasse entspricht einem Python-Dikt, wobei Schlüssel als Attribute zugänglich sind.

e(r '[A-Za-z]+|[!?.:,()]')

        def __init__(self, url, cache_dir, vocabulary_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')
            wenn nicht os.path.isfile(self._pages_path):
                print('Seiten lesen')
                self._read_pages(url)
            wenn nicht os.path.isfile( self._vocabulary_path):
                print('Build vocabulary')
                self._build_vocabulary(vocabulary_size)
            mit bz2.open(self._vocabulary_path, 'rt') als Vokabular:
               print('Vokabeln lesen')
                self._vocabulary = [x.strip() for x in vocabulary]
            self._indices = {x: i for i, x in enumerate(self._vocabulary)🎜>        def __iter__(self):
            mit bz2.open(self._pages_path, 'rt') als Seiten:
                für Seite in Seiten:
                  Wörter = page.strip().split()
                    Wörter = [self.encode(x ) für x in Wörtern]
                    ergeben Wörter
        @property
        def vocabulary_size(self):
            return len(self._vocabulary)
        def. encode (Selbst, Wort):
            zurück 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)
            mit bz2.open(wikipedia_path) als Wikipedia,
                bz2.open(self._pages_path, 'wt') als Seiten:
                für _, Element in se(wikipedia, tag='{*}page'):
                    if element.find('./{*}redirect') is not None:
                      continue
                    page = element.findtext('./{*} revision/{*}text')
                    Words = self._tokenize(page)
                    seiten.write(' '.join(words) + 'n')
                    element.clear()
        def _build_vocabulary(self, vocabulary_size):
            counter = Collections.Counter()
          mit bz2.open(self._pages_path, 'rt') als Seiten:
                für Seite in Seiten:
                   Wörter = Seite .strip().split()
                    counter.update(words)
            common = [''] + counter.most_common(vocabulary_size - 1)
            common = [x[0] for x gemeinsam]
            mit bz2.open(self._vocabulary_path, 'wt') als Vokabular:
                für Wort gemeinsam:
                  vocabulary.write(word + 'n')
       @classmethod
        def _tokenize(cls, page):
            Wörter = cls.TOKEN_REGEX.findall(page)
            Wörter = [x.lower() für x in Wörtern]
            Wörter zurückgeben

Tensorflow importieren as tf
   numpy as np
   from helpers import lazy_property
   class EmbeddingModel:
        def __init__(self, data, target, params):
            self.data = data
           selbst. 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 activate(self) :
            optimierer = tf.train.MomentumOptimizer(
                self.params.learning_rate, self.params.momentum)
            returnoptimierer.minimize(self.cost)
        @lazy_prop erty
        def cost( self):
            eingebettet = tf.nn.embedding_lookup(self.embeddings, self.data)
            Weight = tf.Variable(tf.truncated_normal(
                [self.params.vocabulary_size, self.params .embedding_size ],
                stddev=1.0 / self.params.embedding_size ** 0.5))
            Bias = tf.Variable(tf.zeros([self.params.vocabulary_size]))
            target =. tf .expand_dims( self.target, 1)
            return tf.reduce_mean(tf.nn.nce_loss(
                Weight, Bias, Embedded, Target,
                self.params.contrastive_examples,
               self.params.vocabulary_size))

Sammlungen importieren
   tensorflow als tf importieren
   numpy als np importieren
   aus Batch-Import gestapelt
   aus EmbeddingModel import EmbeddingModel
   aus Skipgrams importiere Skipgrams
   aus Wikipedia importiere Wikipedia
from helpers import AttrDict
   WIKI_DOWNLOAD_DIR = './wikipedia'
   params = AttrDict(
        vocabulary_size=10000,
        max_context=10,
        embedding_size=200 ,
        contrastive_examples=100,
        learning_rate=0.5,
        momentum=0.5,
        batch_size=1000,
   )
   data = tf.placeholder(tf.int32, [None])
   target = tf. Platzhalter( tf.int32, [Keine])
   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, param s.max_context)
   batches =batched( Beispiele, params.batch_size)
   sess = tf.Session()
   sess.run(tf.initialize_all_variables())
   average =collections.deque(maxlen=100)
   für Index, Batch-In enumerate(batches):
        Feed_dict = {data: Batch[0], Target: Batch[1] >        Average.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)

Das obige ist der detaillierte Inhalt vonDetailliertes Beispiel für die Einbettung von Wortvektoren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!