Tensorflow 무게 초기화

Question

tensorflow 웹 사이트의 MNIST tutorial에 대해서는 다른 무게 초기화가 학습에 미치는 영향을 알아보기 위해 실험 (gist)을 실행했습니다. 나는 인기있는 [Xavier, Glorot 2010] paper에서 읽은 것에 반해, 학습은 체중 초기화에 관계없이 괜찮다고 생각했습니다.

상이한 곡선 컨벌루션 완전히 접속 층의 가중치를 초기화 w 다른 값을 나타낸다. 0.3 및 1.0은 성능이 저하되고 일부 값은 더 빠르게 변함 - 특히 0.03 및 0.1이 가장 빠르다고해도 w의 모든 값이 정상적으로 작동합니다. 그럼에도 불구하고 음모는 비교적 큰 범위의 w을 보여 주며 '견고성'을 시사합니다. 무게 초기화.

def weight_variable(shape, w=0.1): 
    initial = tf.truncated_normal(shape, stddev=w) 
    return tf.Variable(initial) 

def bias_variable(shape, w=0.1): 
    initial = tf.constant(w, shape=shape) 
    return tf.Variable(initial) 

질문 : 왜이 ​​네트워크가 사라지는 또는 폭발 그라데이션 문제에서 고통을하지 않는 이유는 무엇입니까?

구현 세부 정보는 요점을 읽으시겠습니까?하지만 여기서는 참조 용 코드입니다. 내 nvidia 960m에서 약 1 시간이 걸렸습니다. 시간 내에 CPU에서 실행될 수 있다고 상상합니다. 자신의 그라데이션이 모든 < 1, 그래서 그들의 이상이 다시 전파, 작은 그라디언트가된다 (아주 빠르게) 동안 곱 때문에 RelU이 가지고있는 반면

import time 
from tensorflow.examples.tutorials.mnist import input_data 
import tensorflow as tf 
from tensorflow.python.client import device_lib 

import numpy 
import matplotlib.pyplot as pyplot 

mnist = input_data.read_data_sets('MNIST_data', one_hot=True) 

# Weight initialization 

def weight_variable(shape, w=0.1): 
    initial = tf.truncated_normal(shape, stddev=w) 
    return tf.Variable(initial) 

def bias_variable(shape, w=0.1): 
    initial = tf.constant(w, shape=shape) 
    return tf.Variable(initial) 


# Network architecture 

def conv2d(x, W): 
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME') 

def max_pool_2x2(x): 
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], 
        strides=[1, 2, 2, 1], padding='SAME') 

def build_network_for_weight_initialization(w): 
    """ Builds a CNN for the MNIST-problem: 
    - 32 5x5 kernels convolutional layer with bias and ReLU activations 
    - 2x2 maxpooling 
    - 64 5x5 kernels convolutional layer with bias and ReLU activations 
    - 2x2 maxpooling 
    - Fully connected layer with 1024 nodes + bias and ReLU activations 
    - dropout 
    - Fully connected softmax layer for classification (of 10 classes) 

    Returns the x, and y placeholders for the train data, the output 
    of the network and the dropbout placeholder as a tuple of 4 elements. 
    """ 
    x = tf.placeholder(tf.float32, shape=[None, 784]) 
    y_ = tf.placeholder(tf.float32, shape=[None, 10]) 

    x_image = tf.reshape(x, [-1,28,28,1]) 
    W_conv1 = weight_variable([5, 5, 1, 32], w) 
    b_conv1 = bias_variable([32], w) 

    h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1) 
    h_pool1 = max_pool_2x2(h_conv1) 
    W_conv2 = weight_variable([5, 5, 32, 64], w) 
    b_conv2 = bias_variable([64], w) 

    h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2) 
    h_pool2 = max_pool_2x2(h_conv2) 

    W_fc1 = weight_variable([7 * 7 * 64, 1024], w) 
    b_fc1 = bias_variable([1024], w) 

    h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64]) 
    h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1) 

    keep_prob = tf.placeholder(tf.float32) 
    h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob) 

    W_fc2 = weight_variable([1024, 10], w) 
    b_fc2 = bias_variable([10], w) 

    y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2 

    return (x, y_, y_conv, keep_prob) 


# Experiment 

def evaluate_for_weight_init(w): 
    """ Returns an accuracy learning curve for a network trained on 
    10000 batches of 50 samples. The learning curve has one item 
    every 100 batches.""" 
    with tf.Session() as sess: 
    x, y_, y_conv, keep_prob = build_network_for_weight_initialization(w) 
    cross_entropy = tf.reduce_mean(
     tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv)) 
    train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy) 
    correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1)) 
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) 
    sess.run(tf.global_variables_initializer()) 
    lr = [] 
    for _ in range(100): 
     for i in range(100): 
      batch = mnist.train.next_batch(50) 
      train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5}) 
     assert mnist.test.images.shape[0] == 10000 
     # This way the accuracy-evaluation fits in my 2GB laptop GPU. 
     a = sum(
      accuracy.eval(feed_dict={ 
       x: mnist.test.images[2000*i:2000*(i+1)], 
       y_: mnist.test.labels[2000*i:2000*(i+1)], 
       keep_prob: 1.0}) 
      for i in range(5))/5 
     lr.append(a) 
    return lr 


ws = [0.0001, 0.0003, 0.001, 0.003, 0.01, 0.03, 0.1, 0.3, 1.0] 
accuracies = [ 
    [evaluate_for_weight_init(w) for w in ws] 
    for _ in range(3) 
] 


# Plotting results 

pyplot.plot(numpy.array(accuracies).mean(0).T) 
pyplot.ylim(0.9, 1) 
pyplot.xlim(0,140) 
pyplot.xlabel('batch (x 100)') 
pyplot.ylabel('test accuracy') 
pyplot.legend(ws) 

Answer 1

물류 기능, 그라디언트를 소멸하는 경향이다 양수 부분에 1의 그래디언트가 있으므로이 문제가 없습니다.

또한 네트워크는 그로 인해 어려움이 없습니다.

Answer 2

가중치 초기화 전략은 모델 개선에있어 중요하고 종종 간과 될 수있는 단계이며, 이제는 Google에서 가장 중요한 결과이므로 더 자세한 답변이 필요하다고 생각했습니다.

일반적으로 각 레이어의 활성화 함수 그래디언트, 입력/출력 연결 수 (fan_in/fan_out) 및 가중치의 분산의 총합은 1과 같아야합니다. 이 방법을 사용하면 네트워크를 통해 역 전파 할 때 입력 및 출력 그라디언트의 차이가 일관되게 유지되고 그라디언트가 폭발하거나 사라지는 것을 경험하지 않아도됩니다. ReLU가 폭발/소멸 그라데이션에 내성이 있지만 문제는 여전히 남아 있습니다.

OP가 사용하는 tf.truncated_normal은 가중치를 "다르게"업데이트하도록 권장하지만 임의의 초기화는 이 아니며은 위의 최적화 전략을 고려합니다. 소규모 네트워크에서는 문제가되지 않지만 더 깊은 네트워크 또는 빠른 교육 시간을 원한다면 최근 조사를 기반으로 한 체중 초기화 전략을 시도하는 것이 가장 좋습니다.

tf.contrib.layers하십시오 ReLU 앞에 무게를 들어

당신의 기본 설정을 사용할 수 있습니다 작동합니다.variance_scaling_initializer TANH/시그 모이 드 활성화 층 "자비"에 대한

더 적합 할 수 있습니다 : 이러한 기능 및 관련 서류 모두

tf.contrib.layers.xavier_initializer

자세한 내용 수 에서 찾을 수 있습니다 : https://www.tensorflow.org/versions/r0.12/api_docs/python/contrib.layers/initializers

더 이상 최적화 c ould 배치 정규화 탐색 : https://www.tensorflow.org/api_docs/python/tf/nn/batch_normalization