PyTorch

init parameters

PyTorch gestisce l’inizializzazione automaticamente, ma ci sono casi in cui serve inizializzare i parametri manualmente. L’approccio base è il seguente:

1
class MultiLayerPerceptronClass(nn.Module):
2
    """
3
        Multilayer Perceptron (MLP) Class
4
    """
5
    def __init__(self,name='mlp',xdim=784,hdim=256,ydim=10):
6
        super(MultiLayerPerceptronClass,self).__init__()
7
        self.name = name
8
        self.xdim = xdim
9
        self.hdim = hdim
10
        self.ydim = ydim
11
        self.lin_1 = nn.Linear(
12
            # FILL IN HERE
13
        )
14
        self.lin_2 = nn.Linear(
15
            # FILL IN HERE
16
        )
17
        self.init_param() # inizializza i parametri
18

19
    def init_param(self):
20
        nn.init.kaiming_normal_(self.lin_1.weight)
21
        nn.init.zeros_(self.lin_1.bias)
22
        nn.init.kaiming_normal_(self.lin_2.weight)
23
        nn.init.zeros_(self.lin_2.bias)
24

25
    def forward(self,x):
26
        net = x
27
        net = self.lin_1(net)
28
        net = F.relu(net)
29
        net = self.lin_2(net)
30
        return net
31

32
M = MultiLayerPerceptronClass(name='mlp',xdim=784,hdim=256,ydim=10).to(device)
33
loss = nn.CrossEntropyLoss()
34
optm = optim.Adam(M.parameters(),lr=1e-3)
35
print ("Done.")

session

Un grande vantaggio di PyTorch è l’assenza delle sessioni. Anche TensorFlow ha eliminato le sessioni dalla v2. Senza sessioni si può eseguire un forward pass direttamente come mostrato sotto.

forward

Non è strettamente necessario chiamare forward in modo esplicito — PyTorch lo gestisce automaticamente. Però essere espliciti rende il codice più leggibile.

1
x_numpy = np.random.rand(2,784)
2
x_torch = torch.from_numpy(x_numpy).float().to(device)
3
y_torch = M.forward(x_torch) # forward path
4
# y_torch = M(x_torch) # forward path
5
y_numpy = y_torch.detach().cpu().numpy() # torch tensor to numpy array
6
print ("x_numpy:\n",x_numpy)
7
print ("x_torch:\n",x_torch)
8
print ("y_torch:\n",y_torch)
9
print ("y_numpy:\n",y_numpy)

model.eval()

Avevo una comprensione vaga di questa funzione, quindi ecco un riepilogo.

Layer come BatchNormalization e Dropout sono pensati solo per il training e non dovrebbero essere attivi durante la predizione. Per disattivarli, considerare la chiamata a model.eval() prima della predizione come una pratica standard.

view

Una funzione che cambia la forma di un tensor mantenendo il numero totale di elementi. Equivale a reshape di numpy. Passare -1 per una dimensione lascia che PyTorch calcoli automaticamente la dimensione.

1
batch_in.view(-1, 28*28)

item

Tutti i valori sono gestiti come oggetti tensor. Per convertirne uno in un semplice scalare (ad esempio un float), si usa item.

1
n_correct += (y_pred==y_trgt).sum().item()

train

1
print ("Start training.")
2
M.init_param() # inizializza i parametri
3
M.train()
4
EPOCHS,print_every = 10,1
5
for epoch in range(EPOCHS):
6
    loss_val_sum = 0
7
    for batch_in,batch_out in train_iter:
8
        # Forward path
9
        y_pred = M.forward(batch_in.view(-1, 28*28).to(device))
10
        loss_out = loss(y_pred,batch_out.to(device))
11
        # Update
12
        optm.zero_grad()      # azzera il gradiente
13
        loss_out.backward()      # backpropagation
14
        optm.step()      # aggiornamento dell'ottimizzatore
15
        loss_val_sum += loss_out
16
    loss_val_avg = loss_val_sum/len(train_iter)
17
    # Print
18
    if ((epoch%print_every)==0) or (epoch==(EPOCHS-1)):
19
        train_accr = func_eval(M,train_iter,device)
20
        test_accr = func_eval(M,test_iter,device)
21
        print ("epoch:[%d] loss:[%.3f] train_accr:[%.3f] test_accr:[%.3f]."%
22
               (epoch,loss_val_avg,train_accr,test_accr))
23
print ("Done")

optm.zero_grad()

In precedenza abbiamo definito l’ottimizzatore così, specificando quali parametri addestrare:

1
optm = optim.Adam(M.parameters(),lr=1e-3)

zero_grad() azzera i gradienti di quei parametri.

loss()

È la funzione di loss definita prima come cross entropy. Passando l’output del modello y_pred e le label di training batch_out restituisce un oggetto che rappresenta la loss.

backward()

Esegue la backpropagation per ogni peso.

step()

Aggiorna i parametri usando il learning rate dell’ottimizzatore e gli altri iperparametri.