API Python Autograd e inizializzatore
Questo capitolo tratta l'API autograd e inizializzatore in MXNet.
mxnet.autograd
Questa è l'API autograd di MXNet per NDArray. Ha la seguente classe:
Classe: Funzione ()
Viene utilizzato per la differenziazione personalizzata in autograd. Può essere scritto comemxnet.autograd.Function. Se, per qualsiasi motivo, l'utente non desidera utilizzare i gradienti calcolati dalla regola concatenata predefinita, può utilizzare la classe Function di mxnet.autograd per personalizzare la differenziazione per il calcolo. Ha due metodi: Forward () e Backward ().
Cerchiamo di capire il funzionamento di questa classe con l'aiuto dei seguenti punti:
Innanzitutto, dobbiamo definire il nostro calcolo nel metodo forward.
Quindi, dobbiamo fornire la differenziazione personalizzata nel metodo a ritroso.
Ora durante il calcolo del gradiente, invece della funzione all'indietro definita dall'utente, mxnet.autograd utilizzerà la funzione all'indietro definita dall'utente. Possiamo anche eseguire il cast su numpy array e viceversa per alcune operazioni in avanti e indietro.
Example
Prima di utilizzare la classe mxnet.autograd.function, definiamo una funzione sigmoide stabile con metodi all'indietro e in avanti come segue:
class sigmoid(mx.autograd.Function):
def forward(self, x):
y = 1 / (1 + mx.nd.exp(-x))
self.save_for_backward(y)
return y
def backward(self, dy):
y, = self.saved_tensors
return dy * y * (1-y)Ora, la classe della funzione può essere utilizzata come segue:
func = sigmoid()
x = mx.nd.random.uniform(shape=(10,))
x.attach_grad()
with mx.autograd.record():
m = func(x)
m.backward()
dx_grad = x.grad.asnumpy()
dx_gradOutput
Quando esegui il codice, vedrai il seguente output:
array([0.21458015, 0.21291625, 0.23330082, 0.2361367 , 0.23086983,
0.24060014, 0.20326573, 0.21093895, 0.24968489, 0.24301809],
dtype=float32)Metodi e loro parametri
Di seguito sono riportati i metodi ei relativi parametri della classe mxnet.autogard.function:
| Metodi e suoi parametri | Definizione |
|---|---|
| forward (heads [, head_grads, keep_graph, ...]) | Questo metodo viene utilizzato per il calcolo in avanti. |
| indietro (heads [, head_grads, keep_graph, ...]) | Questo metodo viene utilizzato per il calcolo all'indietro. Calcola i gradienti delle teste rispetto alle variabili precedentemente contrassegnate. Questo metodo accetta tanti input quanti output di forward. Restituisce anche tanti NDArray quanti sono gli input del forward. |
| get_symbol (x) | Questo metodo viene utilizzato per recuperare la cronologia dei calcoli registrata come file Symbol. |
| grad (teste, variabili [, head_grads, ...]) | Questo metodo calcola i gradienti delle teste rispetto alle variabili. Una volta calcolati, invece di memorizzare in variable.grad, i gradienti verranno restituiti come nuovi NDArray. |
| is_recording () | Con l'aiuto di questo metodo possiamo ottenere lo stato della registrazione e non della registrazione. |
| is_training () | Con l'aiuto di questo metodo possiamo ottenere lo stato dell'allenamento e della previsione. |
| mark_variables (variabili, gradienti [, grad_reqs]) | Questo metodo contrassegnerà NDArrays come variabili per calcolare il gradiente per autograd. Questo metodo è lo stesso della funzione .attach_grad () in una variabile, ma l'unica differenza è che con questa chiamata possiamo impostare il gradiente su qualsiasi valore. |
| pausa ([train_mode]) | Questo metodo restituisce un contesto di ambito da utilizzare nell'istruzione "with" per i codici che non richiedono il calcolo dei gradienti. |
| predic_mode () | Questo metodo restituisce un contesto di ambito da utilizzare nell'istruzione "with" in cui il comportamento del passaggio in avanti è impostato sulla modalità di inferenza e cioè senza modificare gli stati di registrazione. |
| record ([train_mode]) | Restituirà un file autograd registrazione del contesto dell'ambito da utilizzare nell'istruzione "with" e cattura il codice che richiede il calcolo dei gradienti. |
| set_recording (is_recording) | Simile a is_recoring (), con l'aiuto di questo metodo possiamo ottenere lo stato della registrazione e non della registrazione. |
| set_training (is_training) | Simile a is_traininig (), con l'aiuto di questo metodo possiamo impostare lo stato su training o previsione. |
| train_mode () | Questo metodo restituirà un contesto di ambito da utilizzare nell'istruzione "with" in cui il comportamento del passaggio in avanti è impostato sulla modalità di addestramento e cioè senza modificare gli stati di registrazione. |
Esempio di implementazione
Nell'esempio seguente, utilizzeremo il metodo mxnet.autograd.grad () per calcolare il gradiente di testa rispetto alle variabili -
x = mx.nd.ones((2,))
x.attach_grad()
with mx.autograd.record():
z = mx.nd.elemwise_add(mx.nd.exp(x), x)
dx_grad = mx.autograd.grad(z, [x], create_graph=True)
dx_gradOutput
L'output è menzionato di seguito:
[
[3.7182817 3.7182817]
<NDArray 2 @cpu(0)>]Possiamo usare il metodo mxnet.autograd.predict_mode () per restituire uno scope da usare nell'istruzione 'with' -
with mx.autograd.record():
y = model(x)
with mx.autograd.predict_mode():
y = sampling(y)
backward([y])mxnet.intializer
Questa è l'API di MXNet per l'inizializzatore di pesata. Ha le seguenti classi:
Classi e loro parametri
Di seguito sono riportati i metodi ei relativi parametri di mxnet.autogard.function classe:
| Classi e suoi parametri | Definizione |
|---|---|
| Bilineare () | Con l'aiuto di questa classe possiamo inizializzare il peso per i layer di up-sampling. |
| Costante (valore) | Questa classe inizializza i pesi su un dato valore. Il valore può essere sia scalare che NDArray che corrisponde alla forma del parametro da impostare. |
| FusedRNN (init, num_hidden, num_layers, modalità) | Come suggerisce il nome, questa classe inizializza i parametri per i layer Recurrent Neural Network (RNN) fusi. |
| InitDesc | Agisce come descrittore per il modello di inizializzazione. |
| Inizializzatore (** kwargs) | Questa è la classe base di un inizializzatore. |
| LSTMBias ([dimenticare_bias]) | Questa classe inizializza tutti i bias di un LSTMCell su 0,0 ma tranne il dimenticare gate il cui bias è impostato su un valore personalizzato. |
| Carica (param [, default_init, verbose]) | Questa classe inizializza le variabili caricando i dati dal file o dal dizionario. |
| MSRAPrelu ([factor_type, slope]) | Come suggerisce il nome, questa classe inizializza il peso in base a una carta MSRA. |
| Misto (modelli, inizializzatori) | Inizializza i parametri utilizzando più inizializzatori. |
| Normale ([sigma]) | La classe Normal () inizializza i pesi con valori casuali campionati da una distribuzione normale con media zero e deviazione standard (SD) di sigma. |
| Uno() | Inizializza i pesi del parametro su uno. |
| Ortogonale ([scale, rand_type]) | Come suggerisce il nome, questa classe inizializza il peso come matrice ortogonale. |
| Uniforme ([scale]) | Inizializza i pesi con valori casuali che vengono campionati in modo uniforme da un determinato intervallo. |
| Xavier ([rnd_type, factor_type, magnitude]) | In realtà restituisce un inizializzatore che esegue l'inizializzazione "Xavier" per i pesi. |
| Zero() | Inizializza i pesi del parametro a zero. |
Esempio di implementazione
Nell'esempio seguente, useremo la classe mxnet.init.Normal () per creare un inizializzatore e recuperare i suoi parametri -
init = mx.init.Normal(0.8)
init.dumps()Output
L'output è fornito di seguito:
'["normal", {"sigma": 0.8}]'Example
init = mx.init.Xavier(factor_type="in", magnitude=2.45)
init.dumps()Output
L'output è mostrato di seguito:
'["xavier", {"rnd_type": "uniform", "factor_type": "in", "magnitude": 2.45}]'Nell'esempio seguente, utilizzeremo la classe mxnet.initializer.Mixed () per inizializzare i parametri utilizzando più inizializzatori:
init = mx.initializer.Mixed(['bias', '.*'], [mx.init.Zero(),
mx.init.Uniform(0.1)])
module.init_params(init)
for dictionary in module.get_params():
for key in dictionary:
print(key)
print(dictionary[key].asnumpy())Output
L'output è mostrato di seguito:
fullyconnected1_weight
[[ 0.0097627 0.01856892 0.04303787]]
fullyconnected1_bias
[ 0.]