Ta strona została przetłumaczona przez Cloud Translation API.
Switch to English

Neuronowe tłumaczenie maszynowe z uwagą

Zobacz na TensorFlow.org Uruchom w Google Colab Wyświetl źródło na GitHub Pobierz notatnik

Ten notatnik uczy modelu sekwencyjnego (seq2seq) do tłumaczenia z hiszpańskiego na angielski. Jest to zaawansowany przykład, który zakłada pewną wiedzę na temat modeli sekwencyjnych.

Po przeszkoleniu modelu w tym notatniku będziesz mógł wprowadzić hiszpańskie zdanie, takie jak „¿todavia estan en casa?” i zwróć angielskie tłumaczenie: „czy nadal jesteś w domu?”

Jakość tłumaczenia jest rozsądna dla przykładu zabawki, ale wygenerowany wykres uwagi jest być może bardziej interesujący. To pokazuje, na które części zdania wejściowego model zwraca uwagę podczas tłumaczenia:

hiszpańsko-angielska fabuła uwagi

 import tensorflow as tf

import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
from sklearn.model_selection import train_test_split

import unicodedata
import re
import numpy as np
import os
import io
import time
 

Pobierz i przygotuj zbiór danych

Użyjemy zbioru danych językowych dostarczonego przez http://www.manythings.org/anki/ Ten zestaw danych zawiera pary tłumaczeń językowych w formacie:

 May I borrow this book? ¿Puedo tomar prestado este libro?
 

Dostępnych jest wiele języków, ale użyjemy zestawu danych angielsko-hiszpańskiego. Dla wygody umieściliśmy kopię tego zbioru danych w Google Cloud, ale możesz też pobrać własną kopię. Po pobraniu zbioru danych wykonaj następujące czynności, aby przygotować dane:

  1. Dodaj token początku i końca do każdego zdania.
  2. Wyczyść zdania, usuwając znaki specjalne.
  3. Utwórz indeks słów i odwrotny indeks słów (słowniki odwzorowujące słowa → id i id → słowo).
  4. Dopełnij każde zdanie do maksymalnej długości.
 # Download the file
path_to_zip = tf.keras.utils.get_file(
    'spa-eng.zip', origin='http://storage.googleapis.com/download.tensorflow.org/data/spa-eng.zip',
    extract=True)

path_to_file = os.path.dirname(path_to_zip)+"/spa-eng/spa.txt"
 
Downloading data from http://storage.googleapis.com/download.tensorflow.org/data/spa-eng.zip
2646016/2638744 [==============================] - 0s 0us/step

 # Converts the unicode file to ascii
def unicode_to_ascii(s):
  return ''.join(c for c in unicodedata.normalize('NFD', s)
      if unicodedata.category(c) != 'Mn')


def preprocess_sentence(w):
  w = unicode_to_ascii(w.lower().strip())

  # creating a space between a word and the punctuation following it
  # eg: "he is a boy." => "he is a boy ."
  # Reference:- https://stackoverflow.com/questions/3645931/python-padding-punctuation-with-white-spaces-keeping-punctuation
  w = re.sub(r"([?.!,¿])", r" \1 ", w)
  w = re.sub(r'[" "]+', " ", w)

  # replacing everything with space except (a-z, A-Z, ".", "?", "!", ",")
  w = re.sub(r"[^a-zA-Z?.!,¿]+", " ", w)

  w = w.strip()

  # adding a start and an end token to the sentence
  # so that the model know when to start and stop predicting.
  w = '<start> ' + w + ' <end>'
  return w
 
 en_sentence = u"May I borrow this book?"
sp_sentence = u"¿Puedo tomar prestado este libro?"
print(preprocess_sentence(en_sentence))
print(preprocess_sentence(sp_sentence).encode('utf-8'))
 
<start> may i borrow this book ? <end>
b'<start> \xc2\xbf puedo tomar prestado este libro ? <end>'

 # 1. Remove the accents
# 2. Clean the sentences
# 3. Return word pairs in the format: [ENGLISH, SPANISH]
def create_dataset(path, num_examples):
  lines = io.open(path, encoding='UTF-8').read().strip().split('\n')

  word_pairs = [[preprocess_sentence(w) for w in l.split('\t')]  for l in lines[:num_examples]]

  return zip(*word_pairs)
 
 en, sp = create_dataset(path_to_file, None)
print(en[-1])
print(sp[-1])
 
<start> if you want to sound like a native speaker , you must be willing to practice saying the same sentence over and over in the same way that banjo players practice the same phrase over and over until they can play it correctly and at the desired tempo . <end>
<start> si quieres sonar como un hablante nativo , debes estar dispuesto a practicar diciendo la misma frase una y otra vez de la misma manera en que un musico de banjo practica el mismo fraseo una y otra vez hasta que lo puedan tocar correctamente y en el tiempo esperado . <end>

 def tokenize(lang):
  lang_tokenizer = tf.keras.preprocessing.text.Tokenizer(
      filters='')
  lang_tokenizer.fit_on_texts(lang)

  tensor = lang_tokenizer.texts_to_sequences(lang)

  tensor = tf.keras.preprocessing.sequence.pad_sequences(tensor,
                                                         padding='post')

  return tensor, lang_tokenizer
 
 def load_dataset(path, num_examples=None):
  # creating cleaned input, output pairs
  targ_lang, inp_lang = create_dataset(path, num_examples)

  input_tensor, inp_lang_tokenizer = tokenize(inp_lang)
  target_tensor, targ_lang_tokenizer = tokenize(targ_lang)

  return input_tensor, target_tensor, inp_lang_tokenizer, targ_lang_tokenizer
 

Ogranicz rozmiar zbioru danych, aby szybciej eksperymentować (opcjonalnie)

Szkolenie na pełnym zestawie danych obejmującym> 100 000 zdań zajmie dużo czasu. Aby trenować szybciej, możemy ograniczyć rozmiar zbioru danych do 30000 zdań (oczywiście jakość tłumaczenia obniża się przy mniejszej ilości danych):

 # Try experimenting with the size of that dataset
num_examples = 30000
input_tensor, target_tensor, inp_lang, targ_lang = load_dataset(path_to_file, num_examples)

# Calculate max_length of the target tensors
max_length_targ, max_length_inp = target_tensor.shape[1], input_tensor.shape[1]
 
 # Creating training and validation sets using an 80-20 split
input_tensor_train, input_tensor_val, target_tensor_train, target_tensor_val = train_test_split(input_tensor, target_tensor, test_size=0.2)

# Show length
print(len(input_tensor_train), len(target_tensor_train), len(input_tensor_val), len(target_tensor_val))
 
24000 24000 6000 6000

 def convert(lang, tensor):
  for t in tensor:
    if t!=0:
      print ("%d ----> %s" % (t, lang.index_word[t]))
 
 print ("Input Language; index to word mapping")
convert(inp_lang, input_tensor_train[0])
print ()
print ("Target Language; index to word mapping")
convert(targ_lang, target_tensor_train[0])
 
Input Language; index to word mapping
1 ----> <start>
4 ----> tom
42 ----> tiene
2344 ----> tos
3 ----> .
2 ----> <end>

Target Language; index to word mapping
1 ----> <start>
5 ----> tom
51 ----> has
9 ----> a
1554 ----> cough
3 ----> .
2 ----> <end>

Utwórz zbiór danych tf.data

 BUFFER_SIZE = len(input_tensor_train)
BATCH_SIZE = 64
steps_per_epoch = len(input_tensor_train)//BATCH_SIZE
embedding_dim = 256
units = 1024
vocab_inp_size = len(inp_lang.word_index)+1
vocab_tar_size = len(targ_lang.word_index)+1

dataset = tf.data.Dataset.from_tensor_slices((input_tensor_train, target_tensor_train)).shuffle(BUFFER_SIZE)
dataset = dataset.batch(BATCH_SIZE, drop_remainder=True)
 
 example_input_batch, example_target_batch = next(iter(dataset))
example_input_batch.shape, example_target_batch.shape
 
(TensorShape([64, 16]), TensorShape([64, 11]))

Napisz model kodera i dekodera

Zaimplementuj model kodera-dekodera z uwagą, o którym można przeczytać w samouczku TensorFlow Neural Machine Translation (seq2seq) . W tym przykładzie zastosowano nowszy zestaw interfejsów API. Ten notatnik implementuje równania uwagi z samouczka seq2seq. Poniższy diagram pokazuje, że mechanizm uwagi przypisuje każdemu słowu wejściowemu wagę, która jest następnie wykorzystywana przez dekoder do przewidywania następnego słowa w zdaniu. Poniższy rysunek i formuły są przykładem mechanizmu uwagi z artykułu Luonga .

mechanizm uwagi

Dane wejściowe są przepuszczane przez model kodera, który daje nam wyjście kodera w kształcie (rozmiar_batchu, długość_maksymalna, rozmiar_zamknięty) i stan ukrycia kształtu kodera (rozmiar_batchu, rozmiar_zamknięty) .

Oto równania, które są realizowane:

Równanie uwagi 0Równanie uwagi 1

Ten samouczek wykorzystuje uwagę Bahdanau dla kodera. Zdecydujmy się na notację przed napisaniem uproszczonej formy:

  • FC = w pełni połączona (gęsta) warstwa
  • EO = wyjście enkodera
  • H = stan ukryty
  • X = wejście do dekodera

I pseudokod:

  • score = FC(tanh(FC(EO) + FC(H)))
  • attention weights = softmax(score, axis = 1) . Softmax jest domyślnie stosowany na ostatniej osi, ale tutaj chcemy zastosować go na pierwszej osi , ponieważ kształt punktacji to (rozmiar_partii, długość_maksymalna, rozmiar_zamknięty) . Max_length to długość naszego wejścia. Ponieważ próbujemy przypisać wagę do każdego wejścia, na tej osi należy zastosować softmax.
  • context vector = sum(attention weights * EO, axis = 1) . Z tego samego powodu co powyżej, aby wybrać oś jako 1.
  • embedding output = wejście do dekodera X przechodzi przez warstwę osadzającą.
  • merged vector = concat(embedding output, context vector)
  • Ten scalony wektor jest następnie przekazywany do GRU

Kształty wszystkich wektorów na każdym kroku zostały określone w komentarzach w kodzie:

 class Encoder(tf.keras.Model):
  def __init__(self, vocab_size, embedding_dim, enc_units, batch_sz):
    super(Encoder, self).__init__()
    self.batch_sz = batch_sz
    self.enc_units = enc_units
    self.embedding = tf.keras.layers.Embedding(vocab_size, embedding_dim)
    self.gru = tf.keras.layers.GRU(self.enc_units,
                                   return_sequences=True,
                                   return_state=True,
                                   recurrent_initializer='glorot_uniform')

  def call(self, x, hidden):
    x = self.embedding(x)
    output, state = self.gru(x, initial_state = hidden)
    return output, state

  def initialize_hidden_state(self):
    return tf.zeros((self.batch_sz, self.enc_units))
 
 encoder = Encoder(vocab_inp_size, embedding_dim, units, BATCH_SIZE)

# sample input
sample_hidden = encoder.initialize_hidden_state()
sample_output, sample_hidden = encoder(example_input_batch, sample_hidden)
print ('Encoder output shape: (batch size, sequence length, units) {}'.format(sample_output.shape))
print ('Encoder Hidden state shape: (batch size, units) {}'.format(sample_hidden.shape))
 
Encoder output shape: (batch size, sequence length, units) (64, 16, 1024)
Encoder Hidden state shape: (batch size, units) (64, 1024)

 class BahdanauAttention(tf.keras.layers.Layer):
  def __init__(self, units):
    super(BahdanauAttention, self).__init__()
    self.W1 = tf.keras.layers.Dense(units)
    self.W2 = tf.keras.layers.Dense(units)
    self.V = tf.keras.layers.Dense(1)

  def call(self, query, values):
    # query hidden state shape == (batch_size, hidden size)
    # query_with_time_axis shape == (batch_size, 1, hidden size)
    # values shape == (batch_size, max_len, hidden size)
    # we are doing this to broadcast addition along the time axis to calculate the score
    query_with_time_axis = tf.expand_dims(query, 1)

    # score shape == (batch_size, max_length, 1)
    # we get 1 at the last axis because we are applying score to self.V
    # the shape of the tensor before applying self.V is (batch_size, max_length, units)
    score = self.V(tf.nn.tanh(
        self.W1(query_with_time_axis) + self.W2(values)))

    # attention_weights shape == (batch_size, max_length, 1)
    attention_weights = tf.nn.softmax(score, axis=1)

    # context_vector shape after sum == (batch_size, hidden_size)
    context_vector = attention_weights * values
    context_vector = tf.reduce_sum(context_vector, axis=1)

    return context_vector, attention_weights
 
 attention_layer = BahdanauAttention(10)
attention_result, attention_weights = attention_layer(sample_hidden, sample_output)

print("Attention result shape: (batch size, units) {}".format(attention_result.shape))
print("Attention weights shape: (batch_size, sequence_length, 1) {}".format(attention_weights.shape))
 
Attention result shape: (batch size, units) (64, 1024)
Attention weights shape: (batch_size, sequence_length, 1) (64, 16, 1)

 class Decoder(tf.keras.Model):
  def __init__(self, vocab_size, embedding_dim, dec_units, batch_sz):
    super(Decoder, self).__init__()
    self.batch_sz = batch_sz
    self.dec_units = dec_units
    self.embedding = tf.keras.layers.Embedding(vocab_size, embedding_dim)
    self.gru = tf.keras.layers.GRU(self.dec_units,
                                   return_sequences=True,
                                   return_state=True,
                                   recurrent_initializer='glorot_uniform')
    self.fc = tf.keras.layers.Dense(vocab_size)

    # used for attention
    self.attention = BahdanauAttention(self.dec_units)

  def call(self, x, hidden, enc_output):
    # enc_output shape == (batch_size, max_length, hidden_size)
    context_vector, attention_weights = self.attention(hidden, enc_output)

    # x shape after passing through embedding == (batch_size, 1, embedding_dim)
    x = self.embedding(x)

    # x shape after concatenation == (batch_size, 1, embedding_dim + hidden_size)
    x = tf.concat([tf.expand_dims(context_vector, 1), x], axis=-1)

    # passing the concatenated vector to the GRU
    output, state = self.gru(x)

    # output shape == (batch_size * 1, hidden_size)
    output = tf.reshape(output, (-1, output.shape[2]))

    # output shape == (batch_size, vocab)
    x = self.fc(output)

    return x, state, attention_weights
 
 decoder = Decoder(vocab_tar_size, embedding_dim, units, BATCH_SIZE)

sample_decoder_output, _, _ = decoder(tf.random.uniform((BATCH_SIZE, 1)),
                                      sample_hidden, sample_output)

print ('Decoder output shape: (batch_size, vocab size) {}'.format(sample_decoder_output.shape))
 
Decoder output shape: (batch_size, vocab size) (64, 4935)

Zdefiniuj optymalizator i funkcję straty

 optimizer = tf.keras.optimizers.Adam()
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(
    from_logits=True, reduction='none')

def loss_function(real, pred):
  mask = tf.math.logical_not(tf.math.equal(real, 0))
  loss_ = loss_object(real, pred)

  mask = tf.cast(mask, dtype=loss_.dtype)
  loss_ *= mask

  return tf.reduce_mean(loss_)
 

Punkty kontrolne (zapisywanie w oparciu o obiekty)

 checkpoint_dir = './training_checkpoints'
checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt")
checkpoint = tf.train.Checkpoint(optimizer=optimizer,
                                 encoder=encoder,
                                 decoder=decoder)
 

Trening

  1. Przepuszcza dane wejściowe przez koder, który zwraca wyjście kodera i stan ukryty kodera .
  2. Wyjście kodera, stan ukryty kodera i wejście dekodera (które jest tokenem startowym ) są przekazywane do dekodera.
  3. Dekoder zwraca przewidywania i stan ukryty dekodera .
  4. Ukryty stan dekodera jest następnie przekazywany z powrotem do modelu, a prognozy są wykorzystywane do obliczenia strat.
  5. Użyj wymuszania nauczyciela, aby zdecydować o kolejnym wejściu do dekodera.
  6. Wymuszanie przez nauczyciela to technika, w której słowo docelowe jest przekazywane jako następne wejście do dekodera.
  7. Ostatnim krokiem jest obliczenie gradientów i zastosowanie go do optymalizatora i wstecznej propagacji.
 @tf.function
def train_step(inp, targ, enc_hidden):
  loss = 0

  with tf.GradientTape() as tape:
    enc_output, enc_hidden = encoder(inp, enc_hidden)

    dec_hidden = enc_hidden

    dec_input = tf.expand_dims([targ_lang.word_index['<start>']] * BATCH_SIZE, 1)

    # Teacher forcing - feeding the target as the next input
    for t in range(1, targ.shape[1]):
      # passing enc_output to the decoder
      predictions, dec_hidden, _ = decoder(dec_input, dec_hidden, enc_output)

      loss += loss_function(targ[:, t], predictions)

      # using teacher forcing
      dec_input = tf.expand_dims(targ[:, t], 1)

  batch_loss = (loss / int(targ.shape[1]))

  variables = encoder.trainable_variables + decoder.trainable_variables

  gradients = tape.gradient(loss, variables)

  optimizer.apply_gradients(zip(gradients, variables))

  return batch_loss
 
 EPOCHS = 10

for epoch in range(EPOCHS):
  start = time.time()

  enc_hidden = encoder.initialize_hidden_state()
  total_loss = 0

  for (batch, (inp, targ)) in enumerate(dataset.take(steps_per_epoch)):
    batch_loss = train_step(inp, targ, enc_hidden)
    total_loss += batch_loss

    if batch % 100 == 0:
      print('Epoch {} Batch {} Loss {:.4f}'.format(epoch + 1,
                                                   batch,
                                                   batch_loss.numpy()))
  # saving (checkpoint) the model every 2 epochs
  if (epoch + 1) % 2 == 0:
    checkpoint.save(file_prefix = checkpoint_prefix)

  print('Epoch {} Loss {:.4f}'.format(epoch + 1,
                                      total_loss / steps_per_epoch))
  print('Time taken for 1 epoch {} sec\n'.format(time.time() - start))
 
Epoch 1 Batch 0 Loss 4.4937
Epoch 1 Batch 100 Loss 2.3472
Epoch 1 Batch 200 Loss 1.9153
Epoch 1 Batch 300 Loss 1.8042
Epoch 1 Loss 2.0265
Time taken for 1 epoch 27.345187664031982 sec

Epoch 2 Batch 0 Loss 1.5260
Epoch 2 Batch 100 Loss 1.5228
Epoch 2 Batch 200 Loss 1.3840
Epoch 2 Batch 300 Loss 1.3131
Epoch 2 Loss 1.3900
Time taken for 1 epoch 15.777411222457886 sec

Epoch 3 Batch 0 Loss 1.0458
Epoch 3 Batch 100 Loss 0.9216
Epoch 3 Batch 200 Loss 0.9254
Epoch 3 Batch 300 Loss 0.9041
Epoch 3 Loss 0.9699
Time taken for 1 epoch 15.391497373580933 sec

Epoch 4 Batch 0 Loss 0.7582
Epoch 4 Batch 100 Loss 0.7201
Epoch 4 Batch 200 Loss 0.6765
Epoch 4 Batch 300 Loss 0.6696
Epoch 4 Loss 0.6555
Time taken for 1 epoch 15.782341480255127 sec

Epoch 5 Batch 0 Loss 0.3534
Epoch 5 Batch 100 Loss 0.4191
Epoch 5 Batch 200 Loss 0.5322
Epoch 5 Batch 300 Loss 0.4767
Epoch 5 Loss 0.4494
Time taken for 1 epoch 15.508086204528809 sec

Epoch 6 Batch 0 Loss 0.2508
Epoch 6 Batch 100 Loss 0.3366
Epoch 6 Batch 200 Loss 0.2935
Epoch 6 Batch 300 Loss 0.3432
Epoch 6 Loss 0.3137
Time taken for 1 epoch 15.811218738555908 sec

Epoch 7 Batch 0 Loss 0.1759
Epoch 7 Batch 100 Loss 0.1997
Epoch 7 Batch 200 Loss 0.2879
Epoch 7 Batch 300 Loss 0.2643
Epoch 7 Loss 0.2257
Time taken for 1 epoch 15.454826831817627 sec

Epoch 8 Batch 0 Loss 0.1318
Epoch 8 Batch 100 Loss 0.1151
Epoch 8 Batch 200 Loss 0.2130
Epoch 8 Batch 300 Loss 0.1852
Epoch 8 Loss 0.1712
Time taken for 1 epoch 15.786991596221924 sec

Epoch 9 Batch 0 Loss 0.0876
Epoch 9 Batch 100 Loss 0.1227
Epoch 9 Batch 200 Loss 0.1361
Epoch 9 Batch 300 Loss 0.1682
Epoch 9 Loss 0.1328
Time taken for 1 epoch 15.443743467330933 sec

Epoch 10 Batch 0 Loss 0.1048
Epoch 10 Batch 100 Loss 0.0736
Epoch 10 Batch 200 Loss 0.1056
Epoch 10 Batch 300 Loss 0.1204
Epoch 10 Loss 0.1074
Time taken for 1 epoch 15.615742683410645 sec


Tłumaczyć

  • Funkcja oceny jest podobna do pętli szkoleniowej, z tym wyjątkiem, że nie używamy tutaj wymuszania nauczyciela . Dane wejściowe do dekodera w każdym kroku czasowym to jego poprzednie przewidywania wraz ze stanem ukrytym i wyjściem kodera.
  • Przestań przewidywać, kiedy model przewiduje token końcowy .
  • I przechowuj wagi uwagi dla każdego kroku czasowego .
 def evaluate(sentence):
  attention_plot = np.zeros((max_length_targ, max_length_inp))

  sentence = preprocess_sentence(sentence)

  inputs = [inp_lang.word_index[i] for i in sentence.split(' ')]
  inputs = tf.keras.preprocessing.sequence.pad_sequences([inputs],
                                                         maxlen=max_length_inp,
                                                         padding='post')
  inputs = tf.convert_to_tensor(inputs)

  result = ''

  hidden = [tf.zeros((1, units))]
  enc_out, enc_hidden = encoder(inputs, hidden)

  dec_hidden = enc_hidden
  dec_input = tf.expand_dims([targ_lang.word_index['<start>']], 0)

  for t in range(max_length_targ):
    predictions, dec_hidden, attention_weights = decoder(dec_input,
                                                         dec_hidden,
                                                         enc_out)

    # storing the attention weights to plot later on
    attention_weights = tf.reshape(attention_weights, (-1, ))
    attention_plot[t] = attention_weights.numpy()

    predicted_id = tf.argmax(predictions[0]).numpy()

    result += targ_lang.index_word[predicted_id] + ' '

    if targ_lang.index_word[predicted_id] == '<end>':
      return result, sentence, attention_plot

    # the predicted ID is fed back into the model
    dec_input = tf.expand_dims([predicted_id], 0)

  return result, sentence, attention_plot
 
 # function for plotting the attention weights
def plot_attention(attention, sentence, predicted_sentence):
  fig = plt.figure(figsize=(10,10))
  ax = fig.add_subplot(1, 1, 1)
  ax.matshow(attention, cmap='viridis')

  fontdict = {'fontsize': 14}

  ax.set_xticklabels([''] + sentence, fontdict=fontdict, rotation=90)
  ax.set_yticklabels([''] + predicted_sentence, fontdict=fontdict)

  ax.xaxis.set_major_locator(ticker.MultipleLocator(1))
  ax.yaxis.set_major_locator(ticker.MultipleLocator(1))

  plt.show()
 
 def translate(sentence):
  result, sentence, attention_plot = evaluate(sentence)

  print('Input: %s' % (sentence))
  print('Predicted translation: {}'.format(result))

  attention_plot = attention_plot[:len(result.split(' ')), :len(sentence.split(' '))]
  plot_attention(attention_plot, sentence.split(' '), result.split(' '))
 

Przywróć najnowszy punkt kontrolny i wykonaj test

 # restoring the latest checkpoint in checkpoint_dir
checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))
 
<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7ff366a4bcc0>
 translate(u'hace mucho frio aqui.')
 
Input: <start> hace mucho frio aqui . <end>
Predicted translation: it s very cold here . <end> 

png

 translate(u'esta es mi vida.')
 
Input: <start> esta es mi vida . <end>
Predicted translation: this is my life . <end> 

png

 translate(u'¿todavia estan en casa?')
 
Input: <start> ¿ todavia estan en casa ? <end>
Predicted translation: are you still at home ? <end> 

png

 # wrong translation
translate(u'trata de averiguarlo.')
 
Input: <start> trata de averiguarlo . <end>
Predicted translation: try to figure it out . <end> 

png

Następne kroki

  • Pobierz inny zbiór danych, aby eksperymentować z tłumaczeniami, na przykład z angielskiego na niemiecki lub z angielskiego na francuski.
  • Eksperymentuj z uczeniem na większym zbiorze danych lub używając większej liczby epok