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

beta = tf.get_variable("beta", [n_out], initializer=beta_init)

gamma = tf.get_variable("gamma", [n_out], initializer=gamma_init)

batch_mean, batch_var = tf.nn.moments(x, [0,1,2], name='moments')

ema = tf.train.ExponentialMovingAverage(decay=0.9)

ema_apply_op = ema.apply([batch_mean, batch_var])

ema_mean, ema_var = ema.average(batch_mean), ema.average(batch_var)

def mean_var_with_update():

with tf.control_dependencies([ema_apply_op]):

return tf.identity(batch_mean), tf.identity(batch_var)

mean, var = control_flow_ops.cond(phase_train,

mean_var_with_update,

lambda: (ema_mean, ema_var))

normed = tf.nn.batch_norm_with_global_normalization(x, mean, var, beta, gamma, 1e-3, True)

return normed

Так же можно выразить пакетную нормализацию и для несверточных слоев с прямым распространением сигнала — с небольшой модификацией вычисления моментов и преобразованием формы для совместимости с tf.nn.batch_norm_with_global_normalization.

def layer_batch_norm(x, n_out, phase_train):

beta_init = tf.constant_initializer(value=0.0, dtype=tf.float32)

gamma_init = tf.constant_initializer(value=1.0, dtype=tf.float32)

beta = tf.get_variable("beta", [n_out], initializer=beta_init)

gamma = tf.get_variable("gamma", [n_out], initializer=gamma_init)

batch_mean, batch_var = tf.nn.moments(x, [0], name='moments')

ema = tf.train.ExponentialMovingAverage(decay=0.9)

ema_apply_op = ema.apply([batch_mean, batch_var])

ema_mean, ema_var = ema.average(batch_mean), ema.average(batch_var)

def mean_var_with_update():

with tf.control_dependencies([ema_apply_op]):

return tf.identity(batch_mean), tf.identity(batch_var)

mean, var = control_flow_ops.cond(phase_train,

mean_var_with_update,

lambda: (ema_mean, ema_var))

x_r = tf.reshape(x, [-1, 1, 1, n_out])

normed = tf.nn.batch_norm_with_global_normalization(x_r, mean, var, beta, gamma, 1e-3, True)

return tf.reshape(normed, [-1, n_out])

Помимо ускорения обучения (предотвращаются значительные сдвиги в распределении входных значений в каждом слое), пакетная нормализация также позволяет существенно увеличить темп усвоения нового материала. Более того, она служит регуляризатором, устраняет необходимость в прореживании и L2-регуляризации. Мы не будем приводить пример, но авторы также заявляют, что пакетная регуляризация в основном устраняет необходимость фотометрических искажений и мы можем во время обучения поставлять в сеть более «реалистичные» изображения.

Сейчас, разработав усовершенствованное средство анализа естественных изображений при помощи сверточных сетей, мы создадим классификатор для работы с CIFAR-10.

Набор CIFAR-10 состоит из цветных изображений размером 32×32 пиксела, принадлежащих к одному из возможных классов [67]. Это удивительно сложная задача, ведь даже человеку порой тяжело определить, что изображено на картинке. Пример приведен на рис. 5.16.

Рис. 5.16. Собака из набора данных CIFAR-10

В этом разделе мы будем создавать сети с пакетной нормализацией и без нее — для сравнения. Мы увеличим норму обучения для сети с пакетной нормализацией в 10 раз, чтобы извлечь из нее все преимущества. Мы приводим здесь код только для такой сети, потому что обычная сверточная сеть создается очень похожим способом.

Мы деформируем случайным образом обрезанные до размера 24×24 пиксела входящие изображения и загружаем их в нашу сеть для обучения. Применим образец кода, предоставляемый Google. Перейдем сразу к архитектуре сети. Для начала разберемся, как интегрировать пакетную нормализацию в сверточные и полносвязные слои. Как и ожидалось, она применяется к логитам до их поступления в нелинейность:

def conv2d(input, weight_shape, bias_shape, phase_train, visualize=False):

incoming = weight_shape[0] * weight_shape[1] * weight_shape[2]

weight_init = tf.random_normal_initializer(stddev=(2.0/incoming)**0.5)

W = tf.get_variable("W", weight_shape, initializer=weight_init)

if visualize:

filter_summary(W, weight_shape)

bias_init = tf.constant_initializer(value=0)

b = tf.get_variable("b", bias_shape, initializer=bias_init)

logits = tf.nn.bias_add(tf.nn.conv2d(input, W, strides=[1, 1, 1, 1], padding='SAME'), b)

return tf.nn.relu(conv_batch_norm(logits, weight_shape[3], phase_train))

def layer(input, weight_shape, bias_shape, phase_train):

weight_init = tf.random_normal_initializer(stddev=(2.0/weight_shape[0])**0.5)

bias_init = tf.constant_initializer(value=0)

W = tf.get_variable("W", weight_shape, initializer=weight_init)

b = tf.get_variable("b", bias_shape, initializer=bias_init)

logits = tf.matmul(input, W) + b

return tf.nn.relu(layer_batch_norm(logits, weight_shape[1], phase_train))

Дальнейшая архитектура несложная. Мы берем два сверточных слоя (за каждым из которых следует слой подвыборки). Затем идут два полносвязных слоя, а за ними — функция с мягким максимумом. На всякий случай мы включили прореживание, но для версии с пакетной нормализацией во время обучения значение keep_prob = 1:

def inference(x, keep_prob, phase_train):

with tf.variable_scope("conv_1"):

conv_1 = conv2d(x, [5, 5, 3, 64], [64], phase_train, visualize=True)

pool_1 = max_pool(conv_1)

with tf.variable_scope("conv_2"):

conv_2 = conv2d(pool_1, [5, 5, 64, 64], [64], phase_train)

pool_2 = max_pool(conv_2)

with tf.variable_scope("fc_1"):

dim = 1

for d in pool_2.get_shape()[1:].as_list():

dim *= d

pool_2_flat = tf.reshape(pool_2, [-1, dim])

fc_1 = layer(pool_2_flat, [dim, 384], [384], phase_train)

# apply dropout

fc_1_drop = tf.nn.dropout(fc_1, keep_prob)

with tf.variable_scope("fc_2"):

fc_2 = layer(fc_1_drop, [384, 192], [192], phase_train)