Dove posso chiamare la funzione BatchNormalization in Keras?

Se voglio usare la funzione BatchNormalization in Keras, allora devo chiamarla una sola volta all'inizio?

Ho letto questa documentazione per questo: http://keras.io/layers/normalization/

Non vedo dove dovrei chiamarlo. Di seguito è riportato il mio codice che tenta di utilizzarlo:

model = Sequential()
keras.layers.normalization.BatchNormalization(epsilon=1e-06, mode=0, momentum=0.9, weights=None)
model.add(Dense(64, input_dim=14, init='uniform'))
model.add(Activation('tanh'))
model.add(Dropout(0.5))
model.add(Dense(64, init='uniform'))
model.add(Activation('tanh'))
model.add(Dropout(0.5))
model.add(Dense(2, init='uniform'))
model.add(Activation('softmax'))

sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='binary_crossentropy', optimizer=sgd)
model.fit(X_train, y_train, nb_epoch=20, batch_size=16, show_accuracy=True, validation_split=0.2, verbose = 2)

Chiedo perché se eseguo il codice con la seconda riga incluso la normalizzazione batch e se eseguo il codice senza la seconda riga ottengo output simili. Quindi o non sto chiamando la funzione nel posto giusto, o immagino che non faccia molta differenza.

Giusto per rispondere a questa domanda in modo un po 'più dettagliato, e come ha detto Pavel, la normalizzazione in lotti è solo un altro livello, quindi puoi usarlo come tale per creare l'architettura di rete desiderata.

Il caso d'uso generale è usare BN tra i livelli lineari e non lineari della rete, perché normalizza l'input alla funzione di attivazione, in modo da essere centrati nella sezione lineare della funzione di attivazione (come Sigmoid). C'è una piccola discussione qui

Nel tuo caso sopra, questo potrebbe apparire come:

# import BatchNormalization
from keras.layers.normalization import BatchNormalization

# instantiate model
model = Sequential()

# we can think of this chunk as the input layer
model.add(Dense(64, input_dim=14, init='uniform'))
model.add(BatchNormalization())
model.add(Activation('tanh'))
model.add(Dropout(0.5))

# we can think of this chunk as the hidden layer    
model.add(Dense(64, init='uniform'))
model.add(BatchNormalization())
model.add(Activation('tanh'))
model.add(Dropout(0.5))

# we can think of this chunk as the output layer
model.add(Dense(2, init='uniform'))
model.add(BatchNormalization())
model.add(Activation('softmax'))

# setting up the optimization of our weights 
sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='binary_crossentropy', optimizer=sgd)

# running the fitting
model.fit(X_train, y_train, nb_epoch=20, batch_size=16, show_accuracy=True, validation_split=0.2, verbose = 2)

Spero che questo chiarisca le cose un po 'di più.

Questa discussione è fuorviante. Ho provato a commentare la risposta di Lucas Ramadan, ma non ho ancora i privilegi giusti, quindi inserirò qui.

La normalizzazione in batch funziona meglio dopo la funzione di attivazione e qui o qui è il motivo: è stata sviluppata per prevenire lo spostamento della covariata interna. Lo spostamento della covariata interna si verifica quando la distribuzione delle attivazionidi uno strato cambia significativamente durante l'allenamento. La normalizzazione in batch viene utilizzata in modo che la distribuzione degli input (e questi input siano letteralmente il risultato di una funzione di attivazione) su uno strato specifico non cambi nel tempo a causa degli aggiornamenti dei parametri da ciascun batch (o almeno, gli consente di cambiare in modo vantaggioso). Utilizza le statistiche batch per eseguire la normalizzazione, quindi utilizza i parametri di normalizzazione batch (gamma e beta nel documento originale) "per assicurarsi che la trasformazione inserita nella rete possa rappresentare la trasformazione dell'identità" (citazione dal documento originale). Ma il punto è che stiamo provando a normalizzare gli input in un layer, quindi dovrebbe sempre andare immediatamente prima del layer successivo nella rete. Sia che

Questa discussione ha avuto un notevole dibattito sull'opportunità di applicare BN prima della non linearità del livello corrente o alle attivazioni del livello precedente.

Sebbene non vi sia una risposta corretta, gli autori della normalizzazione in lotti affermano che dovrebbe essere applicato immediatamente prima della non linearità del livello corrente. Il motivo (citato dalla carta originale) -

"Aggiungiamo la trasformazione BN immediatamente prima della non linearità, normalizzando x = Wu + b. Avremmo potuto anche normalizzare gli input di layer u, ma poiché è probabile che tu produca un'altra non linearità, è probabile che la forma della sua distribuzione cambi durante l'addestramento e il vincolo del suo primo e secondo momento non eliminerebbero il cambiamento di covariata, al contrario, è più probabile che Wu + b abbia una distribuzione simmetrica e non sparsa, che è "più gaussiana" (Hyv¨arinen & Oja, 2000) ; la normalizzazione probabilmente produrrà attivazioni con una distribuzione stabile. "

Keras ora supporta l' use_bias=Falseopzione, quindi possiamo salvare alcuni calcoli scrivendo come

model.add(Dense(64, use_bias=False))
model.add(BatchNormalization(axis=bn_axis))
model.add(Activation('tanh'))

o

model.add(Convolution2D(64, 3, 3, use_bias=False))
model.add(BatchNormalization(axis=bn_axis))
model.add(Activation('relu'))

Ora è quasi diventato una tendenza avere un Conv2Dseguito da un ReLuseguito da un BatchNormalizationlivello. Così ho inventato una piccola funzione per chiamarli tutti in una volta. Rende la definizione del modello molto più pulita e più facile da leggere.

def Conv2DReluBatchNorm(n_filter, w_filter, h_filter, inputs):
    return BatchNormalization()(Activation(activation='relu')(Convolution2D(n_filter, w_filter, h_filter, border_mode='same')(inputs)))

È un altro tipo di livello, quindi è necessario aggiungerlo come livello in un punto appropriato del modello

model.add(keras.layers.normalization.BatchNormalization())

Guarda un esempio qui: https://github.com/fchollet/keras/blob/master/examples/kaggle_otto_nn.py

La normalizzazione batch viene utilizzata per normalizzare il livello di input e i livelli nascosti regolando la media e il ridimensionamento delle attivazioni. A causa di questo effetto normalizzante con un livello aggiuntivo nelle reti neurali profonde, la rete può utilizzare un tasso di apprendimento più elevato senza sfumare o esplodere. Inoltre, la normalizzazione batch regolarizza la rete in modo che sia più facile generalizzare ed è quindi superfluo utilizzare il dropout per mitigare il sovradimensionamento.

Subito dopo aver calcolato la funzione lineare usando dire, il Dense () o Conv2D () in Keras, usiamo BatchNormalization () che calcola la funzione lineare in un livello e quindi aggiungiamo la non linearità al livello usando Activation ().

from keras.layers.normalization import BatchNormalization
model = Sequential()
model.add(Dense(64, input_dim=14, init='uniform'))
model.add(BatchNormalization(epsilon=1e-06, mode=0, momentum=0.9, weights=None))
model.add(Activation('tanh'))
model.add(Dropout(0.5))
model.add(Dense(64, init='uniform'))
model.add(BatchNormalization(epsilon=1e-06, mode=0, momentum=0.9, weights=None))
model.add(Activation('tanh'))
model.add(Dropout(0.5))
model.add(Dense(2, init='uniform'))
model.add(BatchNormalization(epsilon=1e-06, mode=0, momentum=0.9, weights=None))
model.add(Activation('softmax'))

sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='binary_crossentropy', optimizer=sgd)
model.fit(X_train, y_train, nb_epoch=20, batch_size=16, show_accuracy=True, 
validation_split=0.2, verbose = 2)

Come viene applicata la normalizzazione batch?

Supponiamo di aver inserito a [l-1] in un livello l. Inoltre abbiamo pesi W [l] e unità di polarizzazione b [l] per lo strato l. Sia un [l] il vettore di attivazione calcolato (cioè dopo aver aggiunto la non linearità) per lo strato l e z [l] sia il vettore prima di aggiungere la non linearità

1. Usando un [l-1] e W [l] possiamo calcolare z [l] per il livello l
2. Di solito nella propagazione feed-forward aggiungeremo unità di polarizzazione a z [l] in questa fase come questa z [l] + b [l], ma nella normalizzazione batch questo passaggio di aggiunta di b [l] non è richiesto e no b Viene utilizzato il parametro [l].
3. Calcola z [l] significa e sottralo da ciascun elemento
4. Dividi (z [l] - media) usando la deviazione standard. Chiamalo Z_temp [l]

5. Ora definisci i nuovi parametri γ e β che cambieranno la scala del livello nascosto come segue:

   z_norm [l] = γ.Z_temp [l] + β

In questo estratto di codice, Dense () prende a [l-1], usa W [l] e calcola z [l]. Quindi il BatchNormalization immediato () eseguirà i passaggi precedenti per dare z_norm [l]. E quindi l'attivazione immediata () calcolerà tanh (z_norm [l]) per dare un [l] cioè

a[l] = tanh(z_norm[l])