Optimización de hiperparametros

Creo que en la funcion en la parte de " for inputs, targets in dataloader: " esta mal:

por eso lo modifique 😃

def train_and_evaluate(model, optimizer, loss_fn, dataloaders, device, num_epochs = 10, lr = 0.001):
  for g in optimizer.param_groups:
    g['lr'] = lr
    
  for epoch in range(num_epochs):
    print('Epoch {}/{}'.format(epoch+1, num_epochs))
    print('-'*10)
    
    for phase in ['train','val']:
      if phase == 'train':
        model.train()
      else:
        model.eval()

      running_loss = RunningMetric() # perdida
      running_acc = RunningMetric() # precision

      for inputs, targets in dataloaders[phase]:
        inputs, targets = inputs.to(device), targets.to(device)
        optimizer.zero_grad()
        with torch.set_grad_enabled(phase == 'train'):
          outputs = net(inputs)
          _, preds = torch.max(outputs,1)
          loss = loss_fn(outputs, targets)
          if phase == 'train':
            loss.backward() #magias: gradientes calculados automaticamente
            optimizer.step() #magia2: actualiza las perillas o los parametros

        batch_size = inputs.size()[0]
        running_loss.update(loss.item()*batch_size,
                           batch_size)
        running_acc.update(torch.sum(preds == targets).float(),
                           batch_size)
      print("Loss: {:.4f} Acc: {:.4f} ".format(running_loss(),
                                              running_acc()))
  return model, running_loss(), running_acc()

No entiendo porque pero me estaba marcando el siguiente error al correr la funcion de train_and_evaluate:

Input type (torch.cuda.FloatTensor) and weight type (torch.cuda.DoubleTensor) should be the same using batch_norm_2d

Y lo solucione al pasar el input a un tensor tipo Double

inputs = inputs.type(torch.DoubleTensor)

Hola a [email protected],
Me apareció este error "Expected object of device type cuda but got device type cpu for argument "
En la función def forward le he agregado el siguiente código

<x = self.bn1(self.conv1(x.to(device)))>

si quieran ver el lr:
print("Loss{}: {:.4f} Acc{}: {:.4f} lrs{} : ".format(phase,
running_loss(),
phase,
running_acc(),
lr))

Resultados
1

Epoch 10/10
----------
train - LR: 1e-05
Loss: 0.5120 Acc: 0.8310 
val - LR: 1e-05
Loss: 0.6620 Acc: 0.7778 

2

Epoch 10/10
----------
train - LR: 0.0001
Loss: 0.4319 Acc: 0.8623 
val - LR: 0.0001
Loss: 0.5589 Acc: 0.7870 

3

Epoch 10/10
----------
train - LR: 0.001
Loss: 0.1919 Acc: 0.9421 
val - LR: 0.001
Loss: 0.3605 Acc: 0.8750 

Tuve varios errores con el código y los corregí, así que por si alguien le sirve lo dejo aquí

def train_and_evaluate(model, optimizer, loss_fn, dataloaders, device, num_epochs = 10, lr = 0.001):
  for g in optimizer.param_groups:
    g['lr'] = lr
    
  for epoch in range(num_epochs):
    print('Epoch {}/{}'.format(epoch+1, num_epochs))
    print('-'*10)
    
    for phase in ['train','val']:
      if phase == 'train':
        model.train()
      else:
        model.eval()

      running_loss = RunningMetric() # perdida
      running_acc = RunningMetric() #precision

      for inputs, targets in dataloaders[phase]:
        inputs, targets = inputs.to(device), targets.to(device)
        inputs = inputs.type(torch.DoubleTensor)
        optimizer.zero_grad()

        with torch.set_grad_enabled(phase == 'train'):
          outputs = net(inputs.to(device))
          _, preds = torch.max(outputs,1)
          loss = loss_fn(outputs, targets)
          if phase == 'train':
            loss.backward() #magias: gradientes calculados automaticamente
            optimizer.step() #magia2: actualiza las perillas o los parametros

        batch_size = inputs.size()[0]
        running_loss.update(loss.item()*batch_size,
                           batch_size)
        running_acc.update(torch.sum(preds == targets).float(),
                           batch_size)
      print("Loss: {:.4f} Acc: {:.4f} ".format(running_loss(),
                                              running_acc()))
  return model

error: nput type (torch.cuda.DoubleTensor) and weight type (torch.cuda.FloatTensor) should be the same

Solución:
Hay que castear los inputs a “float” antes de llamar el método Net asi:

y correrá todo bien…

Como cometario final mi score fué:

Epoch 10/10
----------
Loss: 0.0914 Acc: 0.9734 
Loss: 0.0905 Acc: 0.9734  

Una pequeñísima optimización

En vez de crear el RandomSearch como lo hace el profesor, se puede hacer de esta manera:

# RandomSearch para el learning rate (optimización del learning rate)
import random

lrs = []
while len(lrs) < 3:
  lr = 10**(-random.randint(3,7)) # Escala logarimica
  if lr not in lrs:
    lrs.append(lr)

El resultado es muy similar con la diferencia que de esta manera no es posible que se repitan valores dentro de lrs

Tampoco pude a mi me salió el siguiente error.

RuntimeError: Expected object of device type cuda but got device type cpu for argument #1 'self' in call to _thnn_conv2d_forward

Volveré

Los resultados del entrenamiento para dos diferentes learning rates después de 10 epochs:

Learning Rate: 0.001
Epoch 10/10
Train: Loss: 0.9192 Acc:0.6933
Valid: Loss: 1.0398 Acc:0.6157

Learning Rate: 1e-5
Train: Loss: 0.7857 Acc:0.7697
Valid: Loss: 0.8794 Acc:0.7130
Epoch 10/10

Creo que hay un error en el codigo. Se deberia instanciar un nuevo en cada iteracion, o de lo contrario las corridas posteriores van a partir de los resultados de los parametros anteriores.

Ademas no se esta instanciando el modelo con los nuevos cambios.

Modifiqué la salida para ver la perdida y el accuracy de train y val

print("Loss{}: {:.4f} Acc{}: {:.4f} ".format(phase,
                                                   running_loss(),
                                                   phase,
                                                   running_acc()))```