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

Loop de entrenamiento de la red neuronal

12/39
Recursos

Aportes 18

Preguntas 4

Ordenar por:

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

Si quieren guardar sus modelos entrenados para servirlos en una App para que los consuma u otras cosas, pueden usar este codigo:

#Para salvar el modelo
torch.save(net.state_dict(), PATH)

#Para cargar el modelo
net.load_state_dict(torch.load('./metal_defects/best_model.pt'))

más información en este link:

https://pytorch.org/tutorials/beginner/saving_loading_models.html

Si obtienen en google colab, el CUDA error(100) quizás olvidar activar en el entorno de ejecución de tipo GPU.

Para esto, vayan a Runtime (Entorno de Ejecución) -> change Runtime Type (cambiar entorno de ejecución) -> Finalmente escoger Hardware GPU.

Me lanza el siguiente error:

Epoch 1/100
----------
---------------------------------------------------------------------------
NotImplementedError                       Traceback (most recent call last)
<ipython-input-70-daa8416f37dc> in <module>()
     10     optimizer.zero_grad()
     11 
---> 12     outputs = net(inputs)
     13     _, preds = torch.max(outputs,1)
     14     loss = loss_fn(outputs, targets)

1 frames
/usr/local/lib/python3.6/dist-packages/torch/nn/modules/module.py in _forward_unimplemented(self, *input)
    221     # https://github.com/python/mypy/issues/8795
    222     def _forward_unimplemented(self, *input: Any) -> None:
--> 223         raise NotImplementedError
    224 
    225     r"""Defines the computation performed at every call.

NotImplementedError: ```

The accuracy is really good: 99% 😎

Loss: 0.0613 Acc: 0.9931
Epoch 100/100

Loss: 0.0646 Acc: 0.9919

Me estaba mostrando el accuracy 0% asi que tuve que agregar en en dataloader el shuffle.

dataloader = DataLoader(trainset, batch_size= 32, shuffle=True)

y con eso el cambio a un 96% despues de 100 epochs.


Loss: 0.0100 Accuracy: 1.0000
Epoch 98/100

Loss: 0.0095 Accuracy: 1.0000
Epoch 99/100

Loss: 0.0090 Accuracy: 1.0000

Podemos entrenarlo, pero si quisiéramos usarlo para predecir como lo haríamos ?

Excelentes resultados!
Epoch 100/100

Loss: 0.0921 Acc: 0.9722

Yo realmente tengo unas dudas de que el Accuracy sea real de 1.0 y tengamos en cambio overfitting, en especial porque no le estamos pasando un validate_set al loop de entrenamiento.

Parece que es más fácil hacerlas en Tensorflow

Excelente explicación

Había leído sobre los terminos Loss y Acuracy, pero es la primera vez que los entiendo concretamente, gracias.

tuve que correr con 400 epochs para que suba al
Loss: 0.0932 Acc: 0.9667

Corrí dos veces el algoritmo presentando los siguientes valores
y

Con la segunda vez que corrió el algoritmo quiere decir que aprendió muy bien o que se fue al overtitting?

Cambien un poco la forma en la que se imprime cada epoch 😃

for epoch in range(num_epochs):
  print('Epoch {}/{}'.format(epoch+1, num_epochs))
  print('(',end='')
  
  running_loss = RunningMetric() # perdida
  running_acc = RunningMetric() #precision
  
  for inputs, targets in dataloader:
    inputs, targets = inputs.to(device), targets.to(device)
    optimizer.zero_grad()   # para volver a lo gradientes a '0', como se ya uso antes para un nuevo batch tendremos que reiniciarlo. 
    
    outputs = net(inputs)
    _, preds = torch.max(outputs,1) # el maximo del resultado de nuestra RN, (resultado_RN, cuantos maximos).
    loss = loss_fn(outputs, targets)
    
    loss.backward() #magias: gradientes calculados automaticamente.
    optimizer.step() #magia2: actualiza las perillas, pesos, 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('=',end='')
  print(") Loss: {:.4f} Acc: {:.4f} \n".format(running_loss(),
                                          running_acc()))

se vería haci:


Epoch 1/100
(===========================) Loss: 1.7911 Acc: 0.1771 

Epoch 2/100
(===========================) Loss: 1.7908 Acc: 0.1887 

Epoch 3/100
(===========================) Loss: 1.7903 Acc: 0.1863 

Epoch 4/100
(===========================) Loss: 1.7899 Acc: 0.2072 

Tengo el sig. error:

Epoch1/100


RuntimeError Traceback (most recent call last)
<ipython-input-56-e5af88b33840> in <module>()
11 optimizer.zero_grad() #tras ejecutar 1 batch anterior, los gradientes se optimizan, con esto se resetean
12
—> 13 outputs = net(inputs)
14 _,preds = torch.max(outputs,1)
15 loss = loss_fn(outputs,targets)

4 frames
/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py in linear(input, weight, bias)
1368 if input.dim() == 2 and bias is not None:
1369 # fused op is marginally faster
-> 1370 ret = torch.addmm(bias, input, weight.t())
1371 else:
1372 output = input.matmul(weight.t())

RuntimeError: size mismatch, m1: [32 x 8192], m2: [128 x 6] at /pytorch/aten/src/THC/generic/THCTensorMathBlas.cu:290

Me ayudan?

Se me presentaron inconvenientes de indentación, typos y finalmente llamar el RunningMetric"()" pero logro correr:

Aquí el resultado de la epoch 100/100
Epoch 100/100

Loss: 0.1228 Acc: 0.9641

😄

Al intentar ejecutar el **loop **de entrenamiento:

  for inputs, targets in dataloader:
    inputs, targets = inputs.to(device), targets.to(device)
    optimizer.zero_grad()

Tengo el siguiente error:

Epoch 1/100
----------
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-30-daa8416f37dc> in <module>()
      7 
      8   for inputs, targets in dataloader:
----> 9     inputs, targets = inputs.to(device), targets.to(device)
     10     optimizer.zero_grad()
     11 

AttributeError: 'tuple' object has no attribute 'to'

El entorno si tiene GPU activa, ya copie el codigo del repositorio del curso, pero no logro ejecutar el entrenamiento.

Muy buena la explicación, pero me desespera que siempre esté escribiendo al final de la pantalla donde están los controles del video y no se ve que está haciendo

Yo tengo la siguiente salida con el código revisado

Epoch  1 / 100
***************
Loss: 1.7765 Acc: 0.2812
---------------------------------------------------------------------------
OSError                                   Traceback (most recent call last)
<ipython-input-74-142bbb1fc028> in <module>()
      6   running_acc = RunningMetric() #Precisión
      7 
----> 8   for inputs, targets in dataloader:
      9     inputs, targets = inputs.to(device), targets.to(device)
     10     optimizer.zero_grad() #Reiniciando el optimizador

5 frames
/usr/local/lib/python3.6/dist-packages/PIL/Image.py in open(fp, mode)
   2816         exclusive_fp = True
   2817 
-> 2818     prefix = fp.read(16)
   2819 
   2820     preinit()

OSError: [Errno 22] Invalid argument