Previsione parola successiva utilizzando il modello di linguaggio tensorflow esempio

Question

Il tensorflow tutorial sul modello di linguaggio permette di calcolare la probabilità di frasi:

probabilities = tf.nn.softmax(logits) 

nei commenti qui sotto specifica anche un modo di prevedere la parola successiva, invece di probabilità, ma non specifica come questo può essere fatto. Quindi, come generare una parola anziché una probabilità usando questo esempio?

lstm = rnn_cell.BasicLSTMCell(lstm_size) 
# Initial state of the LSTM memory. 
state = tf.zeros([batch_size, lstm.state_size]) 

loss = 0.0 
for current_batch_of_words in words_in_dataset: 
    # The value of state is updated after processing each batch of words. 
    output, state = lstm(current_batch_of_words, state) 

    # The LSTM output can be used to make next word predictions 
    logits = tf.matmul(output, softmax_w) + softmax_b 
    probabilities = tf.nn.softmax(logits) 
    loss += loss_function(probabilities, target_words) 

Answer 1

In realtà è un vantaggio che la funzione restituisce una probabilità anziché la parola stessa. Poiché utilizza un elenco di parole, con le probabilità associate, puoi eseguire ulteriori elaborazioni e aumentare la precisione del risultato.

Per rispondere alla tua domanda: Puoi prendere l'elenco di parole, purificarlo e fare in modo che il programma visualizzi la parola con la più alta probabilità.

Answer 2

L'output è un elenco TensorFlow ed è possibile ottenere l'argomento max (la classe più probabile prevista) con una funzione TensorFlow. Questa è normalmente la lista che contiene le probabilità della parola successiva.

Al "valutare il modello" da questo page, la vostra lista di uscita è y nel seguente esempio:

Prima dovremo capire dove abbiamo previsto l'etichetta corretta. tf.argmax è una funzione estremamente utile che fornisce l'indice della voce più alta in un tensore lungo un asse. Ad esempio, tf.argmax(y,1) è l'etichetta che il nostro modello ritiene sia più probabile per ogni input, mentre tf.argmax(y_,1) è la vera etichetta. Possiamo utilizzare tf.equal per verificare se la nostra previsione corrisponde alla verità. correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))

Un altro approccio che è diverso è quello di avere pre-vectorized (codificati incorporati /) parole. È possibile vettorizzare le parole (quindi incorporarle) con Word2vec per accelerare l'apprendimento, si potrebbe voler dare un'occhiata a questo. Ogni parola potrebbe essere rappresentata come un punto in uno spazio di significato di 300 dimensioni, e potresti trovare automaticamente le "N parole" più vicine al punto previsto nello spazio all'uscita della rete. In tal caso, il modo di procedere di argmax non funziona più e potresti probabilmente confrontare la somiglianza del coseno con le parole con cui volevi veramente confrontarti, ma per quello non sono sicuro in realtà in che modo ciò potrebbe causare instabilità numeriche. In tal caso, non rappresenterà le parole come feature, ma i word embeddings su una dimensionalità, diciamo, da 100 a 2000, in base a modelli diversi. Si potrebbe Google qualcosa come questo per maggiori informazioni: "uomo donna regina parola aggiunta word2vec" per capire di più l'argomento delle immersioni.

Nota: quando parlo di word2vec qui, si tratta di utilizzare un modello word2vec esterno pre-formato per consentire all'addestramento di avere solo ingressi pre-incorporati e creare output di incorporamento. Le parole corrispondenti di tali output possono essere ridefinite da word2vec per trovare le corrispondenti parole top top simili.

Si noti che l'approccio che suggerisco non è esatto in quanto sarebbe utile solo sapere se prevediamo ESATTAMENTE la parola che volevamo prevedere. Per un approccio più soft, sarebbe possibile utilizzare le metriche ROUGE o BLEU per valutare il modello nel caso in cui si utilizzino frasi o qualcosa di più lungo di una parola.

Answer 3

È necessario trovare l'argmax delle probabilità e tradurre l'indice in una parola invertendo la mappa word_to_id. Per farlo funzionare, è necessario salvare le probabilità nel modello e quindi recuperarle dalla funzione run_epoch (si potrebbe anche salvare solo l'argmax stesso). Ecco un frammento:

inverseDictionary = dict(zip(word_to_id.values(), word_to_id.keys())) 

def run_epoch(...): 
    decodedWordId = int(np.argmax(logits)) 
    print (" ".join([inverseDictionary[int(x1)] for x1 in np.nditer(x)]) 
    + " got" + inverseDictionary[decodedWordId] + 
    + " expected:" + inverseDictionary[int(y)]) 

Vedi piena attuazione qui: https://github.com/nelken/tf