Merken Sie den Termin vor! Google I / O kehrt vom 18. bis 20. Mai zurück Registrieren Sie sich jetzt
Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Worteinbettungen

Ansicht auf TensorFlow.org In Google Colab ausführen Quelle auf GitHub anzeigen Notizbuch herunterladen

Dieses Tutorial enthält eine Einführung in Worteinbettungen. Sie trainieren Ihre eigenen Worteinbettungen mithilfe eines einfachen Keras-Modells für eine Stimmungsklassifizierungsaufgabe und visualisieren sie dann im Einbettungsprojektor (siehe Abbildung unten).

Screenshot des Einbettungsprojektors

Darstellen von Text als Zahlen

Modelle für maschinelles Lernen verwenden Vektoren (Arrays von Zahlen) als Eingabe. Wenn Sie mit Text arbeiten, müssen Sie zunächst eine Strategie entwickeln, um Zeichenfolgen in Zahlen umzuwandeln (oder den Text zu "vektorisieren"), bevor Sie ihn dem Modell zuführen. In diesem Abschnitt werden drei Strategien dafür vorgestellt.

One-Hot-Codierungen

Als erste Idee könnten Sie jedes Wort in Ihrem Wortschatz "one-hot" codieren. Betrachten Sie den Satz "Die Katze saß auf der Matte". Das Vokabular (oder eindeutige Wörter) in diesem Satz ist (cat, mat, on, sat, the). Um jedes Wort darzustellen, erstellen Sie einen Nullvektor mit einer Länge, die dem Wortschatz entspricht, und platzieren dann eine Eins im Index, der dem Wort entspricht. Dieser Ansatz ist in der folgenden Abbildung dargestellt.

Diagramm von One-Hot-Codierungen

Um einen Vektor zu erstellen, der die Codierung des Satzes enthält, können Sie die One-Hot-Vektoren für jedes Wort verketten.

Codieren Sie jedes Wort mit einer eindeutigen Nummer

Ein zweiter Ansatz, den Sie versuchen könnten, besteht darin, jedes Wort mit einer eindeutigen Nummer zu codieren. Wenn Sie das obige Beispiel fortsetzen, können Sie "cat" 1, "mat" 2 und so weiter zuweisen. Sie könnten dann den Satz "Die Katze saß auf der Matte" als dichten Vektor wie [5, 1, 4, 3, 5, 2] codieren. Dieser Ansatz ist effizient. Anstelle eines spärlichen Vektors haben Sie jetzt einen dichten (wo alle Elemente voll sind).

Dieser Ansatz hat jedoch zwei Nachteile:

  • Die Ganzzahlcodierung ist beliebig (es wird keine Beziehung zwischen Wörtern erfasst).

  • Eine Ganzzahlcodierung kann für ein Modell schwierig zu interpretieren sein. Ein linearer Klassifikator lernt beispielsweise ein einzelnes Gewicht für jedes Merkmal. Da es keine Beziehung zwischen der Ähnlichkeit zweier Wörter und der Ähnlichkeit ihrer Codierungen gibt, ist diese Kombination aus Merkmal und Gewicht nicht aussagekräftig.

Worteinbettungen

Worteinbettungen geben uns die Möglichkeit, eine effiziente, dichte Darstellung zu verwenden, in der ähnliche Wörter eine ähnliche Codierung haben. Wichtig ist, dass Sie diese Codierung nicht manuell angeben müssen. Eine Einbettung ist ein dichter Vektor von Gleitkommawerten (die Länge des Vektors ist ein von Ihnen angegebener Parameter). Anstatt die Werte für die Einbettung manuell anzugeben, handelt es sich um trainierbare Parameter (Gewichte, die das Modell während des Trainings gelernt hat, genauso wie ein Modell Gewichte für eine dichte Schicht lernt). Es ist üblich, Worteinbettungen zu sehen, die 8-dimensional sind (für kleine Datensätze) und bis zu 1024-dimensioniert sind, wenn mit großen Datensätzen gearbeitet wird. Eine höherdimensionale Einbettung kann feinkörnige Beziehungen zwischen Wörtern erfassen, benötigt jedoch mehr Daten zum Lernen.

Diagramm einer Einbettung

Oben ist ein Diagramm für eine Worteinbettung. Jedes Wort wird als 4-dimensionaler Vektor von Gleitkommawerten dargestellt. Eine andere Möglichkeit, sich eine Einbettung vorzustellen, ist die "Nachschlagetabelle". Nachdem diese Gewichte gelernt wurden, können Sie jedes Wort codieren, indem Sie den dichten Vektor nachschlagen, dem es in der Tabelle entspricht.

Einrichten

import io
import os
import re
import shutil
import string
import tensorflow as tf

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense, Embedding, GlobalAveragePooling1D
from tensorflow.keras.layers.experimental.preprocessing import TextVectorization

Laden Sie den IMDb-Datensatz herunter

Sie werden das Large Movie Review-Dataset im Tutorial verwenden. Sie trainieren ein Stimmungsklassifikatormodell für diesen Datensatz und lernen dabei Einbettungen von Grund auf neu. Weitere Informationen zum Laden eines Datensatzes von Grund auf finden Sie im Lernprogramm zum Laden von Text .

Laden Sie das Dataset mit dem Keras-Dateidienstprogramm herunter und sehen Sie sich die Verzeichnisse an.

url = "https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz"

dataset = tf.keras.utils.get_file("aclImdb_v1.tar.gz", url,
                                  untar=True, cache_dir='.',
                                  cache_subdir='')

dataset_dir = os.path.join(os.path.dirname(dataset), 'aclImdb')
os.listdir(dataset_dir)
Downloading data from https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz
84131840/84125825 [==============================] - 7s 0us/step
['imdb.vocab', 'README', 'train', 'imdbEr.txt', 'test']

Schauen Sie sich den train/ Verzeichnis an. Es hat pos und neg Ordner mit Filmkritiken, die als positiv bzw. negativ gekennzeichnet sind. Sie werden Bewertungen aus pos und neg Ordnern verwenden, um ein binäres Klassifizierungsmodell zu trainieren.

train_dir = os.path.join(dataset_dir, 'train')
os.listdir(train_dir)
['urls_unsup.txt',
 'urls_neg.txt',
 'urls_pos.txt',
 'unsupBow.feat',
 'neg',
 'labeledBow.feat',
 'pos',
 'unsup']

Das train außerdem zusätzliche Ordner, die vor dem Erstellen des Trainingsdatensatzes entfernt werden sollten.

remove_dir = os.path.join(train_dir, 'unsup')
shutil.rmtree(remove_dir)

Erstellen Sie als Nächstes eintf.data.Dataset mit tf.keras.preprocessing.text_dataset_from_directory . Weitere Informationen zur Verwendung dieses Dienstprogramms finden Sie in diesem Tutorial zur Textklassifizierung .

Verwenden Sie das train , um sowohl Zug- als auch Validierungsdatensätze mit einem Split von 20% für die Validierung zu erstellen.

batch_size = 1024
seed = 123
train_ds = tf.keras.preprocessing.text_dataset_from_directory(
    'aclImdb/train', batch_size=batch_size, validation_split=0.2,
    subset='training', seed=seed)
val_ds = tf.keras.preprocessing.text_dataset_from_directory(
    'aclImdb/train', batch_size=batch_size, validation_split=0.2,
    subset='validation', seed=seed)
Found 25000 files belonging to 2 classes.
Using 20000 files for training.
Found 25000 files belonging to 2 classes.
Using 5000 files for validation.

Schauen Sie sich einige Filmkritiken und ihre Bezeichnungen (1: positive, 0: negative) aus dem Zugdatensatz an.

for text_batch, label_batch in train_ds.take(1):
  for i in range(5):
    print(label_batch[i].numpy(), text_batch.numpy()[i])
0 b"Oh My God! Please, for the love of all that is holy, Do Not Watch This Movie! It it 82 minutes of my life I will never get back. Sure, I could have stopped watching half way through. But I thought it might get better. It Didn't. Anyone who actually enjoyed this movie is one seriously sick and twisted individual. No wonder us Australians/New Zealanders have a terrible reputation when it comes to making movies. Everything about this movie is horrible, from the acting to the editing. I don't even normally write reviews on here, but in this case I'll make an exception. I only wish someone had of warned me before I hired this catastrophe"
1 b'This movie is SOOOO funny!!! The acting is WONDERFUL, the Ramones are sexy, the jokes are subtle, and the plot is just what every high schooler dreams of doing to his/her school. I absolutely loved the soundtrack as well as the carefully placed cynicism. If you like monty python, You will love this film. This movie is a tad bit "grease"esk (without all the annoying songs). The songs that are sung are likable; you might even find yourself singing these songs once the movie is through. This musical ranks number two in musicals to me (second next to the blues brothers). But please, do not think of it as a musical per say; seeing as how the songs are so likable, it is hard to tell a carefully choreographed scene is taking place. I think of this movie as more of a comedy with undertones of romance. You will be reminded of what it was like to be a rebellious teenager; needless to say, you will be reminiscing of your old high school days after seeing this film. Highly recommended for both the family (since it is a very youthful but also for adults since there are many jokes that are funnier with age and experience.'
0 b"Alex D. Linz replaces Macaulay Culkin as the central figure in the third movie in the Home Alone empire. Four industrial spies acquire a missile guidance system computer chip and smuggle it through an airport inside a remote controlled toy car. Because of baggage confusion, grouchy Mrs. Hess (Marian Seldes) gets the car. She gives it to her neighbor, Alex (Linz), just before the spies turn up. The spies rent a house in order to burglarize each house in the neighborhood until they locate the car. Home alone with the chicken pox, Alex calls 911 each time he spots a theft in progress, but the spies always manage to elude the police while Alex is accused of making prank calls. The spies finally turn their attentions toward Alex, unaware that he has rigged devices to cleverly booby-trap his entire house. Home Alone 3 wasn't horrible, but probably shouldn't have been made, you can't just replace Macauley Culkin, Joe Pesci, or Daniel Stern. Home Alone 3 had some funny parts, but I don't like when characters are changed in a movie series, view at own risk."
0 b"There's a good movie lurking here, but this isn't it. The basic idea is good: to explore the moral issues that would face a group of young survivors of the apocalypse. But the logic is so muddled that it's impossible to get involved.<br /><br />For example, our four heroes are (understandably) paranoid about catching the mysterious airborne contagion that's wiped out virtually all of mankind. Yet they wear surgical masks some times, not others. Some times they're fanatical about wiping down with bleach any area touched by an infected person. Other times, they seem completely unconcerned.<br /><br />Worse, after apparently surviving some weeks or months in this new kill-or-be-killed world, these people constantly behave like total newbs. They don't bother accumulating proper equipment, or food. They're forever running out of fuel in the middle of nowhere. They don't take elementary precautions when meeting strangers. And after wading through the rotting corpses of the entire human race, they're as squeamish as sheltered debutantes. You have to constantly wonder how they could have survived this long... and even if they did, why anyone would want to make a movie about them.<br /><br />So when these dweebs stop to agonize over the moral dimensions of their actions, it's impossible to take their soul-searching seriously. Their actions would first have to make some kind of minimal sense.<br /><br />On top of all this, we must contend with the dubious acting abilities of Chris Pine. His portrayal of an arrogant young James T Kirk might have seemed shrewd, when viewed in isolation. But in Carriers he plays on exactly that same note: arrogant and boneheaded. It's impossible not to suspect that this constitutes his entire dramatic range.<br /><br />On the positive side, the film *looks* excellent. It's got an over-sharp, saturated look that really suits the southwestern US locale. But that can't save the truly feeble writing nor the paper-thin (and annoying) characters. Even if you're a fan of the end-of-the-world genre, you should save yourself the agony of watching Carriers."
0 b'I saw this movie at an actual movie theater (probably the $2.00 one) with my cousin and uncle. We were around 11 and 12, I guess, and really into scary movies. I remember being so excited to see it because my cool uncle let us pick the movie (and we probably never got to do that again!) and sooo disappointed afterwards!! Just boring and not scary. The only redeeming thing I can remember was Corky Pigeon from Silver Spoons, and that wasn\'t all that great, just someone I recognized. I\'ve seen bad movies before and this one has always stuck out in my mind as the worst. This was from what I can recall, one of the most boring, non-scary, waste of our collective $6, and a waste of film. I have read some of the reviews that say it is worth a watch and I say, "Too each his own", but I wouldn\'t even bother. Not even so bad it\'s good.'

Konfigurieren Sie das Dataset für die Leistung

Dies sind zwei wichtige Methoden, die Sie beim Laden von Daten verwenden sollten, um sicherzustellen, dass E / A nicht blockiert werden.

.cache() speichert Daten im Speicher, nachdem sie von der Festplatte geladen wurden. Dadurch wird sichergestellt, dass der Datensatz beim Training Ihres Modells nicht zu einem Engpass wird. Wenn Ihr Dataset zu groß ist, um in den Speicher zu passen, können Sie mit dieser Methode auch einen performanten On-Disk-Cache erstellen, der effizienter zu lesen ist als viele kleine Dateien.

.prefetch() überlappt die Datenvorverarbeitung und die Modellausführung während des Trainings.

Weitere Informationen zu beiden Methoden sowie zum Zwischenspeichern von Daten auf der Festplatte finden Sie im Handbuch zur Datenleistung .

AUTOTUNE = tf.data.AUTOTUNE

train_ds = train_ds.cache().prefetch(buffer_size=AUTOTUNE)
val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)

Verwenden der Einbettungsebene

Keras erleichtert die Verwendung von Worteinbettungen. Schauen Sie sich die Einbettungsebene an .

Die Einbettungsebene kann als Nachschlagetabelle verstanden werden, die von ganzzahligen Indizes (die für bestimmte Wörter stehen) auf dichte Vektoren (deren Einbettungen) abgebildet wird. Die Dimensionalität (oder Breite) der Einbettung ist ein Parameter, mit dem Sie experimentieren können, um festzustellen, was für Ihr Problem gut funktioniert, ähnlich wie Sie mit der Anzahl der Neuronen in einer dichten Schicht experimentieren würden.

# Embed a 1,000 word vocabulary into 5 dimensions.
embedding_layer = tf.keras.layers.Embedding(1000, 5)

Wenn Sie eine Einbettungsebene erstellen, werden die Gewichte für die Einbettung zufällig initialisiert (genau wie bei jeder anderen Ebene). Während des Trainings werden sie schrittweise über die Rückausbreitung angepasst. Nach dem Training codieren die Einbettungen der gelernten Wörter grob Ähnlichkeiten zwischen Wörtern (wie sie für das spezifische Problem gelernt wurden, für das Ihr Modell trainiert wird).

Wenn Sie eine Ganzzahl an eine Einbettungsebene übergeben, ersetzt das Ergebnis jede Ganzzahl durch den Vektor aus der Einbettungstabelle:

result = embedding_layer(tf.constant([1, 2, 3]))
result.numpy()
array([[-0.02569817,  0.04506942, -0.00755316, -0.01831863,  0.01300636],
       [ 0.04893101, -0.01435085, -0.00031649,  0.00297431, -0.01072218],
       [-0.00838199, -0.04035687,  0.01578344, -0.02574025,  0.02484018]],
      dtype=float32)

Bei Text- oder Sequenzproblemen verwendet die Einbettungsschicht einen 2D-Tensor von Ganzzahlen mit Form (samples, sequence_length) , wobei jeder Eintrag eine Folge von Ganzzahlen ist. Es können Sequenzen variabler Länge eingebettet werden. Sie können in die Einbettungsschicht über Stapeln mit den Formen (32, 10) (Stapel von 32 Sequenzen der Länge 10) oder (64, 15) (Stapel von 64 Sequenzen der Länge 15) einspeisen.

Der zurückgegebene Tensor hat eine Achse mehr als die Eingabe, die Einbettungsvektoren sind entlang der neuen letzten Achse ausgerichtet. Übergeben Sie eine (2, 3) Eingabestapel und die Ausgabe ist (2, 3, N)

result = embedding_layer(tf.constant([[0, 1, 2], [3, 4, 5]]))
result.shape
TensorShape([2, 3, 5])

Wenn eine Reihe von Sequenzen als Eingabe angegeben wird, gibt eine Einbettungsebene einen 3D-Gleitkommatensor mit Form zurück (samples, sequence_length, embedding_dimensionality) . Um von dieser Sequenz variabler Länge in eine feste Darstellung umzuwandeln, gibt es verschiedene Standardansätze. Sie können eine RNN-, Aufmerksamkeits- oder Pooling-Ebene verwenden, bevor Sie sie an eine dichte Ebene übergeben. In diesem Tutorial wird Pooling verwendet, da es am einfachsten ist. Die Textklassifizierung mit einem RNN- Tutorial ist ein guter nächster Schritt.

Textvorverarbeitung

Definieren Sie als Nächstes die Schritte zur Vorverarbeitung des Datensatzes, die für Ihr Stimmungsklassifizierungsmodell erforderlich sind. Initialisieren Sie eine TextVectorization-Ebene mit den gewünschten Parametern, um Filmkritiken zu vektorisieren. Sie können in dem diese Ebene über die Verwendung von mehr lernen Text Classification Tutorial.

# Create a custom standardization function to strip HTML break tags '<br />'.
def custom_standardization(input_data):
  lowercase = tf.strings.lower(input_data)
  stripped_html = tf.strings.regex_replace(lowercase, '<br />', ' ')
  return tf.strings.regex_replace(stripped_html,
                                  '[%s]' % re.escape(string.punctuation), '')


# Vocabulary size and number of words in a sequence.
vocab_size = 10000
sequence_length = 100

# Use the text vectorization layer to normalize, split, and map strings to
# integers. Note that the layer uses the custom standardization defined above.
# Set maximum_sequence length as all samples are not of the same length.
vectorize_layer = TextVectorization(
    standardize=custom_standardization,
    max_tokens=vocab_size,
    output_mode='int',
    output_sequence_length=sequence_length)

# Make a text-only dataset (no labels) and call adapt to build the vocabulary.
text_ds = train_ds.map(lambda x, y: x)
vectorize_layer.adapt(text_ds)

Erstellen Sie ein Klassifizierungsmodell

Verwenden Sie die Keras Sequential API , um das Stimmungsklassifizierungsmodell zu definieren. In diesem Fall handelt es sich um ein Modell im "Continuous Bag of Words" -Stil.

  • Die TextVectorization Ebene wandelt Zeichenfolgen in Vokabularindizes um. Sie haben bereits initialisiert vectorize_layer als TextVectorization Schicht und Vokabular durch den Aufruf gebaut adapt auf text_ds . Jetzt kann vectorize_layer als erste Ebene Ihres End-to-End-Klassifizierungsmodells verwendet werden und transformierte Zeichenfolgen in die Einbettungsebene einspeisen.
  • Die Embedding verwendet das ganzzahlig codierte Vokabular und sucht den Einbettungsvektor für jeden Wortindex. Diese Vektoren werden als Modellzüge gelernt. Die Vektoren fügen dem Ausgabearray eine Dimension hinzu. Die resultierenden Dimensionen sind: (batch, sequence, embedding) .

  • Die GlobalAveragePooling1D gibt für jedes Beispiel einen Ausgabevektor fester Länge zurück, indem über die Sequenzdimension gemittelt wird. Auf diese Weise kann das Modell Eingaben variabler Länge auf einfachste Weise verarbeiten.

  • Der Ausgabevektor fester Länge wird durch eine vollständig verbundene ( Dense ) Schicht mit 16 verborgenen Einheiten geleitet.

  • Die letzte Schicht ist dicht mit einem einzelnen Ausgangsknoten verbunden.

embedding_dim=16

model = Sequential([
  vectorize_layer,
  Embedding(vocab_size, embedding_dim, name="embedding"),
  GlobalAveragePooling1D(),
  Dense(16, activation='relu'),
  Dense(1)
])

Kompilieren und trainieren Sie das Modell

Sie werden TensorBoard verwenden , um Metriken einschließlich Verlust und Genauigkeit zu visualisieren. Erstellen Sie ein tf.keras.callbacks.TensorBoard .

tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir="logs")

Kompilieren und trainieren Sie das Modell mit dem Adam Optimierer und dem BinaryCrossentropy Verlust.

model.compile(optimizer='adam',
              loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
              metrics=['accuracy'])
model.fit(
    train_ds,
    validation_data=val_ds,
    epochs=15,
    callbacks=[tensorboard_callback])
Epoch 1/15
20/20 [==============================] - 3s 111ms/step - loss: 0.6928 - accuracy: 0.5037 - val_loss: 0.6911 - val_accuracy: 0.4886
Epoch 2/15
20/20 [==============================] - 2s 76ms/step - loss: 0.6899 - accuracy: 0.5037 - val_loss: 0.6867 - val_accuracy: 0.4886
Epoch 3/15
20/20 [==============================] - 2s 77ms/step - loss: 0.6846 - accuracy: 0.5037 - val_loss: 0.6790 - val_accuracy: 0.4886
Epoch 4/15
20/20 [==============================] - 2s 77ms/step - loss: 0.6752 - accuracy: 0.5037 - val_loss: 0.6667 - val_accuracy: 0.4886
Epoch 5/15
20/20 [==============================] - 1s 75ms/step - loss: 0.6606 - accuracy: 0.5037 - val_loss: 0.6487 - val_accuracy: 0.4886
Epoch 6/15
20/20 [==============================] - 1s 74ms/step - loss: 0.6397 - accuracy: 0.5040 - val_loss: 0.6254 - val_accuracy: 0.4976
Epoch 7/15
20/20 [==============================] - 1s 74ms/step - loss: 0.6130 - accuracy: 0.5344 - val_loss: 0.5981 - val_accuracy: 0.5768
Epoch 8/15
20/20 [==============================] - 2s 76ms/step - loss: 0.5817 - accuracy: 0.6170 - val_loss: 0.5687 - val_accuracy: 0.6408
Epoch 9/15
20/20 [==============================] - 1s 75ms/step - loss: 0.5480 - accuracy: 0.6873 - val_loss: 0.5394 - val_accuracy: 0.6814
Epoch 10/15
20/20 [==============================] - 2s 76ms/step - loss: 0.5139 - accuracy: 0.7359 - val_loss: 0.5120 - val_accuracy: 0.7184
Epoch 11/15
20/20 [==============================] - 2s 77ms/step - loss: 0.4814 - accuracy: 0.7665 - val_loss: 0.4877 - val_accuracy: 0.7426
Epoch 12/15
20/20 [==============================] - 2s 76ms/step - loss: 0.4519 - accuracy: 0.7910 - val_loss: 0.4669 - val_accuracy: 0.7582
Epoch 13/15
20/20 [==============================] - 2s 76ms/step - loss: 0.4256 - accuracy: 0.8102 - val_loss: 0.4494 - val_accuracy: 0.7686
Epoch 14/15
20/20 [==============================] - 1s 75ms/step - loss: 0.4025 - accuracy: 0.8219 - val_loss: 0.4349 - val_accuracy: 0.7766
Epoch 15/15
20/20 [==============================] - 1s 75ms/step - loss: 0.3821 - accuracy: 0.8351 - val_loss: 0.4230 - val_accuracy: 0.7864
<tensorflow.python.keras.callbacks.History at 0x7f5f3f7b34e0>

Mit diesem Ansatz erreicht das Modell eine Validierungsgenauigkeit von ca. 84% (beachten Sie, dass das Modell überanpasst, da die Trainingsgenauigkeit höher ist).

Sie können in die Modellzusammenfassung schauen, um mehr über jede Ebene des Modells zu erfahren.

model.summary()
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
text_vectorization (TextVect (None, 100)               0         
_________________________________________________________________
embedding (Embedding)        (None, 100, 16)           160000    
_________________________________________________________________
global_average_pooling1d (Gl (None, 16)                0         
_________________________________________________________________
dense (Dense)                (None, 16)                272       
_________________________________________________________________
dense_1 (Dense)              (None, 1)                 17        
=================================================================
Total params: 160,289
Trainable params: 160,289
Non-trainable params: 0
_________________________________________________________________

Visualisieren Sie die Modellmetriken in TensorBoard.

%load_ext tensorboard
%tensorboard --logdir logs

embedded_classifier_accuracy.png

Rufen Sie die trainierten Worteinbettungen ab und speichern Sie sie auf der Festplatte

Rufen Sie als Nächstes die während des Trainings erlernten Worteinbettungen ab. Die Einbettungen sind Gewichte der Einbettungsebene im Modell. Die Gewichtsmatrix hat die Form (vocab_size, embedding_dimension) .

Erhalten Sie die Gewichte aus dem Modell mit get_layer() und get_weights() . Die Funktion get_vocabulary() stellt das Vokabular zum Erstellen einer Metadatendatei mit einem Token pro Zeile bereit.

weights = model.get_layer('embedding').get_weights()[0]
vocab = vectorize_layer.get_vocabulary()

Schreiben Sie die Gewichte auf die Festplatte. Um den Einbettungsprojektor zu verwenden , laden Sie zwei Dateien im tabulatorgetrennten Format hoch: eine Datei mit Vektoren (die die Einbettung enthalten) und eine Datei mit Metadaten (die die Wörter enthalten).

out_v = io.open('vectors.tsv', 'w', encoding='utf-8')
out_m = io.open('metadata.tsv', 'w', encoding='utf-8')

for index, word in enumerate(vocab):
  if index == 0:
    continue  # skip 0, it's padding.
  vec = weights[index]
  out_v.write('\t'.join([str(x) for x in vec]) + "\n")
  out_m.write(word + "\n")
out_v.close()
out_m.close()

Wenn Sie dieses Lernprogramm in Colaboratory ausführen , können Sie diese Dateien mithilfe des folgenden Snippets auf Ihren lokalen Computer herunterladen (oder den Dateibrowser Ansicht -> Inhaltsverzeichnis -> Dateibrowser verwenden ).

try:
  from google.colab import files
  files.download('vectors.tsv')
  files.download('metadata.tsv')
except Exception:
  pass

Visualisieren Sie die Einbettungen

Laden Sie die Einbettungen auf den Einbettungsprojektor hoch, um sie zu visualisieren.

Öffnen Sie den Einbettungsprojektor (dieser kann auch in einer lokalen TensorBoard-Instanz ausgeführt werden).

  • Klicken Sie auf "Daten laden".

  • Laden Sie die beiden oben erstellten Dateien hoch: vecs.tsv und meta.tsv .

Die von Ihnen trainierten Einbettungen werden jetzt angezeigt. Sie können nach Wörtern suchen, um die nächsten Nachbarn zu finden. Versuchen Sie beispielsweise, nach "schön" zu suchen. Sie können Nachbarn wie "wunderbar" sehen.

Nächste Schritte

Dieses Tutorial hat Ihnen gezeigt, wie Sie Worteinbettungen in einem kleinen Datensatz von Grund auf trainieren und visualisieren.