Was macht die Funktion tf.nn.embedding_lookup?

tf.nn.embedding_lookup(params, ids, partition_strategy='mod', name=None)

Ich kann nicht verstehen, die Pflicht, diese Funktion. Es ist wie eine lookup-Tabelle? Was bedeutet die Rückkehr der Parameter für jeden entsprechenden id (ids)?

Beispielsweise in der skip-gram Modell, wenn wir die tf.nn.embedding_lookup(embeddings, train_inputs)dann für jede train_input findet, entsprechen einbetten?

InformationsquelleAutor der Frage Poorya Pzm | 2016-01-19

113

embedding_lookup Funktion ruft Zeilen ab, von der params tensor. Das Verhalten ist ähnlich wie mit der Indizierung von arrays in numpy. E. g.
```
matrix = np.random.random([1024, 64])  # 64-dimensional embeddings
ids = np.array([0, 5, 17, 33])
print matrix[ids]  # prints a matrix of shape [4, 64] 
```
params argument kann auch eine Liste von Tensoren in diesem Fall die ids verteilt werden unter den Tensoren. Zum Beispiel, eine Liste von 3 Tensoren [2, 64] das Standard-Verhalten ist, dass Sie repräsentieren ids: [0, 3][1, 4][2, 5].

partition_strategy steuert die Art und Weise, wie die ids verteilt die Liste. Die Partitionierung ist nützlich für größere Probleme, wenn die matrix zu groß zu halten, in einem Stück.

InformationsquelleAutor der Antwort Rafał Józefowicz
174

Ja, diese Funktion ist schwer zu verstehen, bis Sie den Punkt.

In seiner einfachsten form, es ist ähnlich wie tf.gather. Es gibt die Elemente von params nach den festgelegten Indizes von ids.

Beispielsweise (vorausgesetzt, Sie sind innerhalb tf.InteractiveSession())
```
params = tf.constant([10,20,30,40])
ids = tf.constant([0,1,2,3])
print tf.nn.embedding_lookup(params,ids).eval()
```
zurückkehren würde [10 20 30 40]weil das erste element (index 0) von params ist 10das zweite element params (index 1) ist 20 usw.

Ähnlich,
```
params = tf.constant([10,20,30,40])
ids = tf.constant([1,1,3])
print tf.nn.embedding_lookup(params,ids).eval()
```
zurückkehren würde [20 20 40].

Aber embedding_lookup ist mehr als das. Die params - argument kann eine Liste von Tensoren, sondern als eine einzige tensor ist.
```
params1 = tf.constant([1,2])
params2 = tf.constant([10,20])
ids = tf.constant([2,0,2,1,2,3])
result = tf.nn.embedding_lookup([params1, params2], ids)
```
In diesem Fall die Indizes angegeben, die in ids entsprechen, die Elemente der Tensoren nach einem partition Strategiewo die Standard-partition-Strategie 'mod'.

In der 'mod' - Strategie, index 0 entspricht dem ersten element des ersten tensor in der Liste. Index 1 entspricht dem ersten element der zweiten tensor. Index 2 entspricht dem ersten element der Dritten - tensor, und so weiter. Einfach index i entspricht das erste element des (i+1) - te tensor , für alle Indizes 0..(n-1)vorausgesetzt, params ist eine Liste von n Tensoren.

Nun, index n nicht entsprechen tensor n+1, da die Liste params enthält nur n Tensoren. Also index n entspricht der zweiten element des ersten tensor. Ähnlich, index n+1 entspricht dem zweiten element des zweiten tensor, etc.

So, in den code
```
params1 = tf.constant([1,2])
params2 = tf.constant([10,20])
ids = tf.constant([2,0,2,1,2,3])
result = tf.nn.embedding_lookup([params1, params2], ids)
```
index 0 entspricht dem ersten element des ersten Tensors: 1

index 1 entspricht dem ersten element des zweiten Tensors: 10

index 2 entspricht dem zweiten element des ersten Tensors: 2

index 3 entspricht dem zweiten element des zweiten Tensors: 20

So, das Ergebnis wäre:
```
[ 2  1  2 10  2 20]
```
InformationsquelleAutor der Antwort Asher Stern

Ja, der Zweck tf.nn.embedding_lookup() Funktion ist die Ausführung eines lookup in der embedding matrix und wieder die Einbettungen (oder in einfachen Worten, der Vektor-Darstellung) der Wörter.

Einer einfachen Einbettung matrix (der Form: vocabulary_size x embedding_dimension) würde wie folgt Aussehen. (d.h. jeder Wort wird vertreten durch ein Vektor von zahlen; daher der name word2vec)

Embedding Matrix

the 0.418 0.24968 -0.41242 0.1217 0.34527 -0.044457 -0.49688 -0.17862
like 0.36808 0.20834 -0.22319 0.046283 0.20098 0.27515 -0.77127 -0.76804
between 0.7503 0.71623 -0.27033 0.20059 -0.17008 0.68568 -0.061672 -0.054638
did 0.042523 -0.21172 0.044739 -0.19248 0.26224 0.0043991 -0.88195 0.55184
just 0.17698 0.065221 0.28548 -0.4243 0.7499 -0.14892 -0.66786 0.11788
national -1.1105 0.94945 -0.17078 0.93037 -0.2477 -0.70633 -0.8649 -0.56118
day 0.11626 0.53897 -0.39514 -0.26027 0.57706 -0.79198 -0.88374 0.30119
country -0.13531 0.15485 -0.07309 0.034013 -0.054457 -0.20541 -0.60086 -0.22407
under 0.13721 -0.295 -0.05916 -0.59235 0.02301 0.21884 -0.34254 -0.70213
such 0.61012 0.33512 -0.53499 0.36139 -0.39866 0.70627 -0.18699 -0.77246
second -0.29809 0.28069 0.087102 0.54455 0.70003 0.44778 -0.72565 0.62309

Aufgeteilt ich die oben genannten embedding matrix geladen und nur die Worte in vocab denen unser Vokabular und die entsprechenden Vektoren in emb array.

vocab = ['the','like','between','did','just','national','day','country','under','such','second']

emb = np.array([[0.418, 0.24968, -0.41242, 0.1217, 0.34527, -0.044457, -0.49688, -0.17862],
   [0.36808, 0.20834, -0.22319, 0.046283, 0.20098, 0.27515, -0.77127, -0.76804],
   [0.7503, 0.71623, -0.27033, 0.20059, -0.17008, 0.68568, -0.061672, -0.054638],
   [0.042523, -0.21172, 0.044739, -0.19248, 0.26224, 0.0043991, -0.88195, 0.55184],
   [0.17698, 0.065221, 0.28548, -0.4243, 0.7499, -0.14892, -0.66786, 0.11788],
   [-1.1105, 0.94945, -0.17078, 0.93037, -0.2477, -0.70633, -0.8649, -0.56118],
   [0.11626, 0.53897, -0.39514, -0.26027, 0.57706, -0.79198, -0.88374, 0.30119],
   [-0.13531, 0.15485, -0.07309, 0.034013, -0.054457, -0.20541, -0.60086, -0.22407],
   [ 0.13721, -0.295, -0.05916, -0.59235, 0.02301, 0.21884, -0.34254, -0.70213],
   [ 0.61012, 0.33512, -0.53499, 0.36139, -0.39866, 0.70627, -0.18699, -0.77246 ],
   [ -0.29809, 0.28069, 0.087102, 0.54455, 0.70003, 0.44778, -0.72565, 0.62309 ]])


emb.shape
# (11, 8)

Einbettung Lookup in TensorFlow

Nun werden wir sehen, wie können wir durchführen Einbettung lookup für einige beliebige Eingangs-Satz.

In [54]: from collections import OrderedDict

# embedding as TF tensor (for now constant; could be tf.Variable() during training)
In [55]: tf_embedding = tf.constant(emb, dtype=tf.float32)

# input for which we need the embedding
In [56]: input_str = "like the country"

# build index based on our `vocabulary`
In [57]: word_to_idx = OrderedDict({w:vocab.index(w) for w in input_str.split() if w in vocab})

# lookup in embedding matrix & return the vectors for the input words
In [58]: tf.nn.embedding_lookup(tf_embedding, list(word_to_idx.values())).eval()
Out[58]: 
array([[ 0.36807999,  0.20834   , -0.22318999,  0.046283  ,  0.20097999,
         0.27515   , -0.77126998, -0.76804   ],
       [ 0.41800001,  0.24968   , -0.41242   ,  0.1217    ,  0.34527001,
        -0.044457  , -0.49687999, -0.17862   ],
       [-0.13530999,  0.15485001, -0.07309   ,  0.034013  , -0.054457  ,
        -0.20541   , -0.60086   , -0.22407   ]], dtype=float32)

Beobachten, wie wir uns das Einbettungen von unseren ursprünglichen Einbettung matrix (mit Worten) über die Indizes der Worte in unserem Wortschatz.

In der Regel, wie eine Einbettung lookup wird durchgeführt, indem die erste Schicht (die so genannte Embedding layer), die geht dann diese Einschlüsse zu RNN/LSTM/GRU Ebenen für die weitere Verarbeitung.

Seite Hinweis: in der Regel der Wortschatz wird auch eine spezielle unk token. Also, wenn ein token von unserer input-Satz ist nicht in unserem Wortschatz, dann wird der index entsprechend unk gesucht in der einbettenden matrix.

P. S. Beachten Sie, dass embedding_dimension ist ein hyperparameter, dass man tune für Ihre Anwendung, sondern auch beliebte Modelle wie Word2Vec und Handschuh verwendet 300 dimension Vektor für die Repräsentation jedes Wort.

Bonus Lesen word2vec skip-Gramm-Modell

InformationsquelleAutor der Antwort kmario23

Wenn die params-tensor ist im hohen Maße, die ids bezieht sich nur auf top-dimension. Vielleicht ist es offensichtlich für die meisten Menschen, aber ich habe auf ausführen den folgenden code zu verstehen, dass:

embeddings = tf.constant([[[1,1],[2,2],[3,3],[4,4]],[[11,11],[12,12],[13,13],[14,14]],
                          [[21,21],[22,22],[23,23],[24,24]]])
ids=tf.constant([0,2,1])
embed = tf.nn.embedding_lookup(embeddings, ids, partition_strategy='div')

with tf.Session() as session:
    result = session.run(embed)
    print (result)

Versucht nur die 'div' - Strategie und für ein tensor ist, macht es keinen Unterschied.

Hier ist die Ausgabe:

[[[ 1  1]
  [ 2  2]
  [ 3  3]
  [ 4  4]]

 [[21 21]
  [22 22]
  [23 23]
  [24 24]]

 [[11 11]
  [12 12]
  [13 13]
  [14 14]]]

InformationsquelleAutor der Antwort Yan Zhao

3

Andere Möglichkeit es zu betrachten ist , davon ausgehen, dass Sie abflachen der Tensoren zu eindimensionalen array, und dann sind Sie nachschlagen

(eg) Tensor0=[1,2,3], Tensor1=[4,5,6], Tensor2=[7,8,9]

Die abgeflacht tensor wie folgt aus
[1,4,7,2,5,8,3,6,9]

Nun, wenn Sie tun, eine Suche [0,3,4,1,7] es wird yeild [1,2,5,4,6]

(i,e), falls lookup-Wert ist 7, zum Beispiel , und wir haben 3 Tensoren (oder einen tensor mit 3 Zeilen), dann,

7 /3 : (zur Erinnerung 1, der Quotient ist 2), So, 2. element von Tensor1 angezeigt werden, die 6

InformationsquelleAutor der Antwort Shanmugam Ramasamy
1

Da war ich auch fasziniert von dieser Funktion, ich gebe meine zwei Cent.

Die Art und Weise sehe ich es in der 2D-Fall ist nur als eine matrix-Multiplikation (es ist einfach zu verallgemeinern und auf anderen Dimensionen).

Betrachten ein Vokabular mit N Symbolen.
Dann können Sie ein symbol x als einen Vektor der Dimensionen Nx1, one-hot codiert ist.

Aber Sie wollen eine Darstellung von diesem symbol nicht als ein Vektor, der Nx1, aber, wie man mit den Abmessungen Mx1, genannt y.

So, zu transformieren x in ydie Sie verwenden können, und die Einbettung matrix Emit den Abmessungen MxN:

y = E x.

Dies ist im wesentlichen das, was tf.nn.embedding_lookup(params, ids, ...) tut, mit der nuance, dass ids sind nur eine Zahl für die position der 1 in der one-hot codierten Vektor x.

InformationsquelleAutor der Antwort joaoaccarvalho
1

Hier ist ein Bild, darstellend die Einbettung von lookup.

Prägnant ist, bekommt es die entsprechenden Zeilen des embedding layer, spezifiziert durch eine Liste von IDs und bieten, wie ein tensor. Es wird erreicht durch den folgenden Prozess.
1. Definieren Sie einen Platzhalter lookup_ids = tf.placeholder([10])
2. Definieren eine Einbettung Schicht embeddings = tf.Variable([100,10],...)
3. Definieren die tensorflow Betrieb embed_lookup = tf.embedding_lookup(embeddings, lookup_ids)
4. Erhalten die Ergebnisse, die durch die Ausführung lookup = session.run(embed_lookup, feed_dict={lookup_ids:[95,4,14]})
InformationsquelleAutor der Antwort thushv89
0

Hinzufügen zu Asher Stern, die Antwort,
params ist
interpretiert als Partitionierung einer großen embedding tensor. Es kann ein einzelner tensor repräsentiert die vollständige Einbettung tensor,
oder eine Liste von X-Tensoren alle gleiche Form, außer der ersten dimension,
Vertretung sharded embedding Tensoren.

Die Funktion tf.nn.embedding_lookup geschrieben ist, in Anbetracht der Tatsache, dass die Einbettung (params) wird groß sein. Deshalb brauchen wir partition_strategy.

InformationsquelleAutor der Antwort Aaron

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.