Нихиль Будума - Основы глубокого обучения

# by 1 forward. (Соответствующая цель — decoder_input со сдвигом вперед на 1)

if length_idx < decoder_size — 1:

target = decoder_inputs[batch_idx][length_idx + 1]

if length_idx == decoder_size — 1 or

target == data_utils.PAD_ID:

batch_weight[batch_idx] = 0.0

batch_weights.append(batch_weight)

return batch_encoder_inputs, batch_decoder_inputs,

batch_weights

Наконец, назначаем нулевые целевые веса для токенов-заполнителей. Подготовка данных завершена, и мы можем начать строить и обучать модель! Сначала определяем код, используемый при обучении и тестировании, на время абстрагируясь от модели. Так можно убедиться, что мы понимаем процесс в общих чертах. Потом можно перейти к более глубокому анализу модели seq2seq. Как всегда, первый шаг в обучении — загрузка данных:

def train():

"""Train a en->fr translation model using WMT data."""

# Prepare WMT data. (Готовим данные WMT)

print("Preparing WMT data in %s" % FLAGS.data_dir)

en_train, fr_train, en_dev, fr_dev, _, _ =

data_utils.prepare_wmt_data(

FLAGS.data_dir, FLAGS.en_vocab_size, FLAGS.fr_vocab_size)

Запустив сессию TensorFlow, первым делом создаем модель. Отметим, что этот метод применим к ряду архитектур, если они удовлетворяют требованиям к формату входных и выходных данных, описанным в методе train():

with tf.Session() as sess:

# Create model. (Создаем модель)

print("Creating %d layers of %d units." % (FLAGS.num_layers, FLAGS.size))

model = create_model(sess, False)

Теперь при помощи разных функций группируем данные; группы позже будут использованы get_batch() для извлечения информации. Создаем набор действительных чисел от 0 до 1, который будет приблизительно определять вероятность выбора группы, нормализованную на размер последней. Метод get_batch() выбирает группы с учетом этих вероятностей:

# Read data into buckets and compute their sizes. (Группируем данные и вычисляем размеры групп)

print ("Reading development and training data (limit: %d)."

% FLAGS.max_train_data_size)

dev_set = read_data(en_dev, fr_dev)

train_set = read_data(en_train, fr_train,

FLAGS.max_train_data_size)

train_bucket_sizes = [len(train_set[b]) for b in xrange(

len(_buckets))]

train_total_size = float(sum(train_bucket_sizes))

# A bucket scale is a list of increasing numbers

# from 0 to 1 that we'll use to select a bucket. (Масштаб группы — список чисел от 0 до 1 по возрастающей, используемых для выбора группы)

# Length of [scale[i], scale[i+1]] is proportional to

# the size if i-th training bucket, as used later. (Длина [scale[i], scale[i+1]] пропорциональна размеру при i-й обучающей группе как показано ниже)

train_buckets_scale = [sum(train_bucket_sizes[: i + 1]) /

train_total_size

for i in xrange(len(

train_bucket_sizes))]

Теперь, когда данные готовы, запускаем основной цикл обучения. Мы инициализируем различные его переменные — например, current_step и previous_losses, делая их пустыми или равными 0. Важно отметить, что каждая итерация цикла соотносится с одной эпохой — полной обработкой пакета обучающих данных. Для эпохи мы выбираем bucket_id, получаем пакет при помощи get_batch, а затем делаем шаг вперед в рамках модели:

# This is the training loop. (Это цикл обучения)

step_time, loss = 0.0, 0.0

current_step = 0

previous_losses = []

while True:

# Choose a bucket according to data distribution. (Выбираем группу на основании распределения данных)

# We pick a random number

# in [0, 1] and use the corresponding interval

# in train_buckets_scale. (Берем случайное число из [0, 1] и используем соответствующий интервал в train_buckets_scale)

random_number_01 = np.random.random_sample()

bucket_id = min([i for i in xrange(len(

train_buckets_scale))

if train_buckets_scale[i] >

random_number_01])

# Get a batch and make a step. (Получаем пакет и делаем шаг)

start_time = time.time()

encoder_inputs, decoder_inputs, target_weights =

model.get_batch(

train_set, bucket_id)

_, step_loss, _ = model.step(sess, encoder_inputs,

decoder_inputs,

target_weights, bucket_id,

False)

Оцениваем потери при предсказании и запоминаем все остальные метрики:

step_time += (time.time() — start_time) /

FLAGS.steps_per_checkpoint

loss += step_loss / FLAGS.steps_per_checkpoint

current_step += 1

Наконец, после некоторого числа итераций, которое предписывается глобальной переменной, нам нужно выполнить ряд дополнительных операций. Сначала выводим статистику для предыдущего пакета: это размер функции потери, темп обучения и перплексия [95]. Если потери не уменьшаются, возможно, модель оказалась в локальном минимуме. Чтобы помочь ей этого избежать, снижаем темп обучения: тогда не будет больших скачков ни в одном направлении. В это же время мы сохраняем копию модели с весами и активациями на диск:

# Once in a while, we save checkpoint, print statistics,

# and run evals. (В определенный момент сохраняем контрольную точку, выводим статистику и проводим оценку)

if current_step % FLAGS.steps_per_checkpoint == 0:

# Print statistics for the previous epoch. (Выводим статистику для предыдущей эпохи)

perplexity = math.exp(float(loss)) if loss <

300 else float("inf")

print ("global step %d learning rate %.4f

step-time %.2f perplexity "

"%.2f" % (model.global_step.eval(),

model.learning_rate.eval(),

step_time, perplexity))

# Decrease learning rate if no improvement was seen over last 3 times. (Снижаем темп обучения, если за последние 3 раза не было улучшений)

if len(previous_losses) > 2 and loss > max(

previous_losses[-3:]):

sess.run(model.learning_rate_decay_op)

previous_losses.append(loss)

# Save checkpoint and zero timer and loss. (Сохраняем контрольную точку, нулевой таймер и величину потерь)

checkpoint_path = os.path.join(FLAGS.train_dir, "translate.ckpt")

model.saver.save(sess, checkpoint_path, global_step=model.global_step)

step_time, loss = 0.0, 0.0

Теперь измеряем производительность нашей модели на тестовом наборе данных. Тем самым мы определяем обобщающую способность модели, чтобы узнать, повышается ли она, и если да, то насколько. Мы снова получаем данные с помощью get_batch, но на этот раз используем bucket_id из тестового набора. Снова делаем шаг вперед в рамках модели, но не обновляем веса, поскольку последний аргумент в методе step() — True — противоположен False во время основного цикла обучения; семантику step() мы рассмотрим позже. Измеряем потери на тестовом наборе данных и выводим их пользователю:

# Run evals on development set and print

# their perplexity. (Запускаем оценки качества на наборе данных для тестирования, печатаем перплексию)

for bucket_id in xrange(len(_buckets)):

if len(dev_set[bucket_id]) == 0:

print(" eval: empty bucket %d" % (bucket_id))

continue

encoder_inputs, decoder_inputs,

target_weights = model.get_batch(

dev_set, bucket_id)

# attns, _, eval_loss, _ = model.step(sess,

encoder_inputs, decoder_inputs,

_, eval_loss, _ = model.step(sess, encoder_inputs,

decoder_inputs,

target_weights,

bucket_id,

True)

eval_ppx = math.exp(float(eval_loss)) if eval_loss <

300 else float(

"inf")

print(" eval: bucket %d perplexity %.2f" % (

bucket_id, eval_ppx))

sys.stdout.flush()

Есть еще один подходящий сценарий использования нашей модели — однократное предсказание. Мы хотим иметь возможность использовать обученную модель для перевода новых предложений — наших или других пользователей. Для этого пользуемся методом decode(). Он включает примерно те же функции, что были реализованы в цикле оценки на тестовом наборе данных. Основное различие в том, что при обучении и оценке нам не требовалось переводить выходные векторные представления в понятные людям токены, а этим мы сейчас и займемся. Изложим метод подробно.

Поскольку это отдельный режим вычислений, необходимо снова запустить сессию TensorFlow и либо создать модель, либо загрузить уже сохраненную в предыдущей контрольной точке:

def decode():

with tf.Session() as sess:

# Create model and load parameters. (Создаем модель и загружаем параметры)

model = create_model(sess, True)

Мы назначаем размер пакета 1, поскольку параллельно не обрабатываем новых предложений, а загружаем только входные и выходные словари, но не сами данные: