Perché nessun calo di peso sugli strati convoluzionali nell'esempio cifar10 di tensorflow?

Question

Sembra che non vi sia alcun decadimento del peso su strati convoluzionali nell'esempio cifar10 su tensorflow. In realtà non c'è decadimento di peso su nessuno strato tranne per i due strati completamente connessi. È una pratica comune? Pensavo che la decomposizione del peso fosse applicata a tutti i pesi (eccetto i pregiudizi).

Per riferimento, ecco il codice corrispondente (wd è il fattore di decadimento peso):

# conv1 
    with tf.variable_scope('conv1') as scope: 
    kernel = _variable_with_weight_decay('weights', shape=[5, 5, 3, 64], 
             stddev=1e-4, wd=0.0) 
    conv = tf.nn.conv2d(images, kernel, [1, 1, 1, 1], padding='SAME') 
    biases = _variable_on_cpu('biases', [64], tf.constant_initializer(0.0)) 
    bias = tf.nn.bias_add(conv, biases) 
    conv1 = tf.nn.relu(bias, name=scope.name) 
    _activation_summary(conv1) 

    # pool1 
    pool1 = tf.nn.max_pool(conv1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1], 
         padding='SAME', name='pool1') 
    # norm1 
    norm1 = tf.nn.lrn(pool1, 4, bias=1.0, alpha=0.001/9.0, beta=0.75, 
        name='norm1') 

    # conv2 
    with tf.variable_scope('conv2') as scope: 
    kernel = _variable_with_weight_decay('weights', shape=[5, 5, 64, 64], 
             stddev=1e-4, wd=0.0) 
    conv = tf.nn.conv2d(norm1, kernel, [1, 1, 1, 1], padding='SAME') 
    biases = _variable_on_cpu('biases', [64], tf.constant_initializer(0.1)) 
    bias = tf.nn.bias_add(conv, biases) 
    conv2 = tf.nn.relu(bias, name=scope.name) 
    _activation_summary(conv2) 

    # norm2 
    norm2 = tf.nn.lrn(conv2, 4, bias=1.0, alpha=0.001/9.0, beta=0.75, 
        name='norm2') 
    # pool2 
    pool2 = tf.nn.max_pool(norm2, ksize=[1, 3, 3, 1], 
         strides=[1, 2, 2, 1], padding='SAME', name='pool2') 

    # local3 
    with tf.variable_scope('local3') as scope: 
    # Move everything into depth so we can perform a single matrix multiply. 
    dim = 1 
    for d in pool2.get_shape()[1:].as_list(): 
     dim *= d 
    reshape = tf.reshape(pool2, [FLAGS.batch_size, dim]) 

    weights = _variable_with_weight_decay('weights', shape=[dim, 384], 
              stddev=0.04, wd=0.004) 
    biases = _variable_on_cpu('biases', [384], tf.constant_initializer(0.1)) 
    local3 = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name) 
    _activation_summary(local3) 

    # local4 
    with tf.variable_scope('local4') as scope: 
    weights = _variable_with_weight_decay('weights', shape=[384, 192], 
              stddev=0.04, wd=0.004) 
    biases = _variable_on_cpu('biases', [192], tf.constant_initializer(0.1)) 
    local4 = tf.nn.relu(tf.matmul(local3, weights) + biases, name=scope.name) 
    _activation_summary(local4) 

    # softmax, i.e. softmax(WX + b) 
    with tf.variable_scope('softmax_linear') as scope: 
    weights = _variable_with_weight_decay('weights', [192, NUM_CLASSES], 
              stddev=1/192.0, wd=0.0) 
    biases = _variable_on_cpu('biases', [NUM_CLASSES], 
           tf.constant_initializer(0.0)) 
    softmax_linear = tf.add(tf.matmul(local4, weights), biases, name=scope.name) 
    _activation_summary(softmax_linear) 

    return softmax_linear 

Answer 1

Peso decadimento non necessariamente migliorare le prestazioni. Nella mia esperienza personale, ho trovato ragionevolmente spesso che i miei modelli si comportano peggio (come misurato da una certa metrica su un set senza limiti) con una quantità significativa di decadimento del peso. È una forma utile di regolarizzazione di cui essere consapevole, ma non è necessario aggiungerlo a tutti i modelli senza considerare se sembra necessario o confrontare le prestazioni con e senza.

Per quanto riguarda il fatto che il calo di peso su una parte di un modello può essere buono rispetto al decadimento del peso sull'intero modello, sembra meno comune regolare solo alcuni dei pesi in questo modo. Non so che ci sia una ragione teorica per questo, comunque. In generale, le reti neurali hanno già troppi iperparametri da configurare. Se usare la decomposizione del peso o no è già una domanda, e quanto sia forte regolarizzare i pesi se lo fai. Se ti chiedi anche quali livelli dovrei regolarizzare in questo modo, ti verrà rapidamente esaurito il tempo per testare le prestazioni di tutti i diversi modi in cui potresti accenderlo e spegnerlo per ogni livello.

Immagino che ci siano modelli che potrebbero beneficiare della decomposizione del peso solo su parte del modello; Non penso che sia fatto spesso perché è difficile testare tutte le possibilità e scoprire quale funziona meglio.