Aprender conceptos iniciales de Deep Learning

1

¿Qué es el Deep Learning?

2

¿Qué son las redes neuronales artificiales?

3

¿Por qué el Deep Learning ahora?

4

Pytorch y los diferentes frameworks de Deep Learning

5

Setup en Google Colab

Entender la API de Pytorch

6

¿Qué son los tensores?

7

Tensores y datasets

8

Capas de una red neuronal en Pytorch

9

Crear una red neuronal en Pytorch

10

¿Cómo cargar datos en Pytorch?

11

¿Cómo entrenar una red en Pytorch?

12

Loop de entrenamiento de la red neuronal

Entrenar Redes Neuronales Profundas

13

Ciclo de trabajo para el Deep Learning

14

Espacio de modelos

15

Función de perdida

16

Método de optimización: SGD y Backpropagation

17

Autograd y métodos de optimización

18

¿Cómo evaluar la performance de la red neuronal?

19

Regularización de redes neuronales profundas

20

Implementando la Regularización

21

Optimización de hiperparametros

22

Transfer learning

Construir nuestro propio modelo

23

Presentación del problema

24

Definiendo la red generativa que construiremos: CycleGAN

25

Creando la red generadora convolucional

26

Creando el decoder de la red generadora

27

Construyendo las redes discriminativas

28

Preparando el entrenamiento

29

Instanciando redes, perdidas

30

Instanciando optimizadores y schedulers

31

Calculando las pérdidas

32

Entrenando

33

Cómo visualizar y debugear el entrenamiento

34

Cómo utilizar tu modelo una vez entrenado

35

Cómo utilizar una GPU personal con Google Cloud

Llegar más lejos

36

¿Por qué el Deep Learning es más poderoso que el Machine Learning Tradicional?

37

Para ir más lejos

38

Cierre del curso

Bonus

39

¿Por qué aprender Deep Learning?

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Optimización de hiperparametros

21/39
Recursos

Aportes 12

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

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()))```