تاریخ را ذخیره کنید! Google I / O 18-20 مه بازمی گردد اکنون ثبت نام کنید
این صفحه به‌وسیله ‏Cloud Translation API‏ ترجمه شده است.
Switch to English

ترجمه ماشین عصبی با توجه

مشاهده در TensorFlow.org در Google Colab اجرا کنید مشاهده منبع در GitHub دانلود دفترچه یادداشت

این دفترچه توالی به دنباله (seq2seq) را برای ترجمه اسپانیایی به انگلیسی آموزش می دهد. این یک مثال پیشرفته است که دانش برخی از توالی به مدل های دنباله را فرض می کند.

پس از آموزش مدل در این دفترچه یادداشت ، می توانید جمله ای اسپانیایی مانند "d todavia estan en casa؟" ، و ترجمه انگلیسی را برگردانید: "آیا هنوز در خانه هستی؟"

کیفیت ترجمه برای یک مثال اسباب بازی مناسب است ، اما طرح توجه تولید شده شاید جالب تر باشد. این نشان می دهد که کدام بخشهای جمله ورودی هنگام ترجمه توجه مدل را دارند:

طرح توجه اسپانیایی-انگلیسی

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

مجموعه داده را بارگیری و آماده کنید

ما از یک مجموعه داده زبانی ارائه شده توسط http://www.manythings.org/anki/ استفاده خواهیم کرد. این مجموعه داده شامل جفت های ترجمه زبان در قالب:

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

زبانهای مختلفی در دسترس است ، اما ما از مجموعه داده انگلیسی-اسپانیایی استفاده خواهیم کرد. برای راحتی کار ، ما یک نسخه از این مجموعه داده را در Google Cloud میزبانی کرده ایم ، اما شما همچنین می توانید نسخه خود را بارگیری کنید. پس از بارگیری مجموعه داده ، در اینجا مراحلی را که برای تهیه داده ها برمی داریم آورده شده است:

  1. به هر جمله یک نشانه شروع و پایان اضافه کنید.
  2. جملات را با حذف نویسه های خاص پاک کنید.
  3. فهرست کلمه و شاخص کلمه معکوس ایجاد کنید (فرهنگ لغت ها از word → id و id → word نگاشت می کنند).
  4. هر جمله را حداکثر طول بزنید.
# 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 line.split('\t')]
                for line 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

اندازه مجموعه داده را برای آزمایش سریعتر محدود کنید (اختیاری)

آموزش در مورد مجموعه داده کامل> 100000 جمله طولانی خواهد بود. برای آموزش سریعتر ، ما می توانیم اندازه مجموعه داده را به 30000 جمله محدود کنیم (البته کیفیت ترجمه با داده های کمتری کاهش می یابد):

# 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(f'{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>
23 ----> te
4128 ----> castigaran
3 ----> .
2 ----> <end>

Target Language; index to word mapping
1 ----> <start>
6 ----> you
75 ----> will
40 ----> be
1252 ----> punished
3 ----> .
2 ----> <end>

یک مجموعه داده 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]))

مدل رمزگذار و رمزگشای را بنویسید

یک مدل رمزگذار-رمزگشای با توجه که می توانید در آموزش TensorFlow Neural Machine Translation (seq2seq) بخوانید را پیاده سازی کنید . این مثال از مجموعه جدیدتر API استفاده می کند. این نوت بوک معادلات توجه را از آموزش seq2seq پیاده سازی می کند. نمودار زیر نشان می دهد که به هر کلمه ورودی وزنی توسط مکانیسم توجه اختصاص داده می شود که سپس توسط رمزگشا برای پیش بینی کلمه بعدی در جمله استفاده می شود. تصویر و فرمول های زیر مثالی از سازوکار توجه مقاله لوونگ است .

مکانیسم توجه

ورودی از طریق یک مدل رمزگذار ارائه می شود که به ما خروجی رمزگذار شکل (اندازه دسته ای ، حداکثر طول ، اندازه مخفی) و حالت مخفی رمزگذار ( شکل اندازه بزرگ)

در اینجا معادلاتی که اجرا می شوند:

معادله توجه 0معادله توجه 1

این آموزش از توجه Bahdanau برای رمزگذار استفاده می کند. بیایید قبل از نوشتن فرم ساده در مورد نت گذاری تصمیم بگیریم:

  • FC = لایه کاملاً متصل (متراکم)
  • EO = خروجی رمزگذار
  • H = حالت پنهان
  • X = ورودی به رسیور

و کد شبه:

  • score = FC(tanh(FC(EO) + FC(H)))
  • attention weights = softmax(score, axis = 1) . Softmax به طور پیش فرض در محور آخر اعمال می شود اما در اینجا می خواهیم آن را در محور 1 اعمال کنیم ، زیرا شکل نمره (اندازه دسته ای ، حداکثر طول ، اندازه مخفی) است . Max_length طول ورودی ماست. از آنجا که ما در حال تلاش برای تعیین وزن به هر ورودی هستیم ، باید softmax در آن محور اعمال شود.
  • context vector = sum(attention weights * EO, axis = 1) . دلیل مشابه بالا برای انتخاب محور 1 است.
  • embedding output = ورودی رسیور X از یک لایه جاسازی شده عبور می کند.
  • merged vector = concat(embedding output, context vector)
  • این بردار ادغام شده سپس به GRU داده می شود

اشکال همه بردارها در هر مرحله در نظرات کد مشخص شده است:

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)', sample_output.shape)
print('Encoder Hidden state shape: (batch size, units)', 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)", attention_result.shape)
print("Attention weights shape: (batch_size, sequence_length, 1)", 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)', sample_decoder_output.shape)
Decoder output shape: (batch_size, vocab size) (64, 4935)

بهینه ساز و عملکرد ضرر را تعریف کنید

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_)

ایست های بازرسی (ذخیره مبتنی بر شی)

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

آموزش

  1. ورودی را از رمزگذار که خروجی رمزگذار و حالت مخفی رمزگذار را برمی گرداند ، عبور دهید.
  2. خروجی رمزگذار ، حالت مخفی رمزگذار و ورودی رمزگشای (که رمز شروع است ) به رمزگشای منتقل می شود.
  3. رسیور پیش بینی ها و حالت پنهان رسیور را برمی گرداند.
  4. سپس حالت پنهان رسیور دوباره به مدل منتقل می شود و از پیش بینی ها برای محاسبه ضرر استفاده می شود.
  5. برای تصمیم گیری در مورد ورودی بعدی رسیور از اجبار معلم استفاده کنید.
  6. اجبار به معلم تکنیکی است که در آن کلمه هدف به عنوان ورودی بعدی به رمزگشا منتقل می شود.
  7. مرحله آخر محاسبه شیب ها و استفاده از آنها برای بهینه ساز و backpropagate است.
@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(f'Epoch {epoch+1} Batch {batch} Loss {batch_loss.numpy():.4f}')
  # saving (checkpoint) the model every 2 epochs
  if (epoch + 1) % 2 == 0:
    checkpoint.save(file_prefix=checkpoint_prefix)

  print(f'Epoch {epoch+1} Loss {total_loss/steps_per_epoch:.4f}')
  print(f'Time taken for 1 epoch {time.time()-start:.2f} sec\n')
Epoch 1 Batch 0 Loss 4.6502
Epoch 1 Batch 100 Loss 2.0552
Epoch 1 Batch 200 Loss 1.7422
Epoch 1 Batch 300 Loss 1.7109
Epoch 1 Loss 2.0188
Time taken for 1 epoch 25.82 sec

Epoch 2 Batch 0 Loss 1.4892
Epoch 2 Batch 100 Loss 1.4136
Epoch 2 Batch 200 Loss 1.3366
Epoch 2 Batch 300 Loss 1.1715
Epoch 2 Loss 1.3655
Time taken for 1 epoch 15.74 sec

Epoch 3 Batch 0 Loss 0.9632
Epoch 3 Batch 100 Loss 0.9077
Epoch 3 Batch 200 Loss 0.8587
Epoch 3 Batch 300 Loss 0.8281
Epoch 3 Loss 0.9333
Time taken for 1 epoch 15.34 sec

Epoch 4 Batch 0 Loss 0.6200
Epoch 4 Batch 100 Loss 0.7250
Epoch 4 Batch 200 Loss 0.5895
Epoch 4 Batch 300 Loss 0.6464
Epoch 4 Loss 0.6215
Time taken for 1 epoch 15.63 sec

Epoch 5 Batch 0 Loss 0.3734
Epoch 5 Batch 100 Loss 0.4286
Epoch 5 Batch 200 Loss 0.4749
Epoch 5 Batch 300 Loss 0.4635
Epoch 5 Loss 0.4223
Time taken for 1 epoch 15.29 sec

Epoch 6 Batch 0 Loss 0.2264
Epoch 6 Batch 100 Loss 0.2074
Epoch 6 Batch 200 Loss 0.2380
Epoch 6 Batch 300 Loss 0.2778
Epoch 6 Loss 0.2936
Time taken for 1 epoch 15.62 sec

Epoch 7 Batch 0 Loss 0.1972
Epoch 7 Batch 100 Loss 0.1869
Epoch 7 Batch 200 Loss 0.2515
Epoch 7 Batch 300 Loss 0.2856
Epoch 7 Loss 0.2102
Time taken for 1 epoch 15.33 sec

Epoch 8 Batch 0 Loss 0.1532
Epoch 8 Batch 100 Loss 0.1566
Epoch 8 Batch 200 Loss 0.1546
Epoch 8 Batch 300 Loss 0.1840
Epoch 8 Loss 0.1573
Time taken for 1 epoch 15.61 sec

Epoch 9 Batch 0 Loss 0.1231
Epoch 9 Batch 100 Loss 0.1207
Epoch 9 Batch 200 Loss 0.1328
Epoch 9 Batch 300 Loss 0.1111
Epoch 9 Loss 0.1220
Time taken for 1 epoch 15.27 sec

Epoch 10 Batch 0 Loss 0.1158
Epoch 10 Batch 100 Loss 0.0811
Epoch 10 Batch 200 Loss 0.1011
Epoch 10 Batch 300 Loss 0.0877
Epoch 10 Loss 0.1006
Time taken for 1 epoch 15.61 sec

ترجمه کردن

  • عملکرد ارزیابی مشابه حلقه آموزش است ، با این تفاوت که ما در اینجا از اجبار معلم استفاده نمی کنیم. ورودی رسیور در هر مرحله ، پیش بینی های قبلی آن همراه با حالت مخفی و خروجی رمزگذار است.
  • وقتی مدل رمز پایان را پیش بینی کرد ، پیش بینی را متوقف کنید .
  • و وزن های توجه را برای هر مرحله از زمان ذخیره کنید .
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:', sentence)
  print('Predicted translation:', result)

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

آخرین ایست بازرسی و آزمون را بازیابی کنید

# restoring the latest checkpoint in checkpoint_dir
checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))
<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f8cb8166dd8>
translate(u'hace mucho frio aqui.')
Input: <start> hace mucho frio aqui . <end>
Predicted translation: it s very cold here . <end>
/home/kbuilder/.local/lib/python3.6/site-packages/ipykernel_launcher.py:9: UserWarning: FixedFormatter should only be used together with FixedLocator
  if __name__ == '__main__':
/home/kbuilder/.local/lib/python3.6/site-packages/ipykernel_launcher.py:10: UserWarning: FixedFormatter should only be used together with FixedLocator
  # Remove the CWD from sys.path while we load stuff.

png

translate(u'esta es mi vida.')
Input: <start> esta es mi vida . <end>
Predicted translation: this is my life . <end>
/home/kbuilder/.local/lib/python3.6/site-packages/ipykernel_launcher.py:9: UserWarning: FixedFormatter should only be used together with FixedLocator
  if __name__ == '__main__':
/home/kbuilder/.local/lib/python3.6/site-packages/ipykernel_launcher.py:10: UserWarning: FixedFormatter should only be used together with FixedLocator
  # Remove the CWD from sys.path while we load stuff.

png

translate(u'¿todavia estan en casa?')
Input: <start> ¿ todavia estan en casa ? <end>
Predicted translation: are you still at home ? <end>
/home/kbuilder/.local/lib/python3.6/site-packages/ipykernel_launcher.py:9: UserWarning: FixedFormatter should only be used together with FixedLocator
  if __name__ == '__main__':
/home/kbuilder/.local/lib/python3.6/site-packages/ipykernel_launcher.py:10: UserWarning: FixedFormatter should only be used together with FixedLocator
  # Remove the CWD from sys.path while we load stuff.

png

# wrong translation
translate(u'trata de averiguarlo.')
Input: <start> trata de averiguarlo . <end>
Predicted translation: try to figure it out . <end>
/home/kbuilder/.local/lib/python3.6/site-packages/ipykernel_launcher.py:9: UserWarning: FixedFormatter should only be used together with FixedLocator
  if __name__ == '__main__':
/home/kbuilder/.local/lib/python3.6/site-packages/ipykernel_launcher.py:10: UserWarning: FixedFormatter should only be used together with FixedLocator
  # Remove the CWD from sys.path while we load stuff.

png

مراحل بعدی

  • برای آزمایش ترجمه ها ، به عنوان مثال انگلیسی به آلمانی یا انگلیسی به فرانسوی ، یک مجموعه داده دیگر بارگیری کنید .
  • با آموزش مجموعه داده بزرگتر یا استفاده از دوره های بیشتر ، تجربه کنید.