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

Creando el decoder de la red generadora

26/39
Recursos

Aportes 6

Preguntas 0

Ordenar por:

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

Honestamente ,este curso esta pesimamente explicado, deberían quitarlo de la lista de cursos de ML e IA, el profesor sabe mucho pero la forma de explicar simplemente poniendo el codigo sin mostrar mas graficamente como se tomarían estas redes es mala, complica a los alumnos, debieron divirdir el curso en diferentes subcursos, empezando por lo basico de pytorch, e ir subiendo de nivel, ni sikiera han explicado como hacer una regresion lineal o logisitica con pytorch pero quieres utilizar redes residuales, debieron ponerlo como los cursos de keras y al final cuando un alumno ya tiene la base le meten un tema complicado, lo unico q hacen con un curso como este es que los alumnos sienten q son uno brutos y dejen la linea de carrera pensando q son ellos los responsables cuando se supone que esta plataforma deber ayudarlos pero con un cursos así hacen todo lo contrario

Hasta este punto creo que puedo inferir que los alumnos ya tenemos más flujo usando Python, quizás por eso va rápido tirando todo el código que puede. En la clase de Keras que también es más avanzado fue más didáctica la explicación y desde la primera hasta la última clase se pudo comprender todo.

Seria bueno que se reconstruya este curso de Pytorch con otra metodología… Quizás se comprenda mejor que hace cada capa por detrás y no solo la parte del código.

Me da risa como el profe dice “debería estar bien” y siempre tiene errores de tipeo, pero esta bien son detalles. Genial el curso!

Código de la clase:


class Generator(nn.Module):
  def __init__(self, input_nc, output_nc, n_residual_blocks=9):
    super(Generator,self).__init__()
    
    # Bloqueconvolucional
    model = [ nn.ReflectionPad2d(3),
            nn.Conv2d(input_nc, 64, F), # I - 7 + 6 /1 +1 = I
            nn.InstanceNorm2d(64),
             nn.ReLU(True)
            ]
    
    in_features = 64
    out_features = in_features * 2
    
    #Encoding
    for _ in range(2):
      model += [ nn.Conv2d(in_features, out_features, 3, stride=2, padding=1), #I/2
                 nn.InstanceNorm2d(out_features),
                 nn.ReLU(True)
               ]
      in_features = out_features
      out_features = in_features*2
    
    #transformaciones residuales
    
    for _ in range(n_residual_blocks):
      model += [ResidualBlock(in_features)]
    
    #decoding
    
    out_features = in_features/2
    for _ in range(2):
      model += [ nn.ConvTransose2d(in_features, out_features, 3, stride=2, padding=1, output_padding=1), #2I
                 nn.InstanceNorm2d(out_features),
                 nn.ReLU(True)
               ]
      in_features = out_features
      out_feature = in_features //2
      
      #salida
      model += [ nn.ReflectionPad2d(3),
                 nn.Conv2d(64, output_nc, 7), #I
                 nn.Tanh()
               ]
      
      self.model = nn.Sequential(*model)
      
    def forward(self,x):
      return self.model(x)

   for _ in range(n_residul_blocks):
      model += [ResidualBlock(in_feactures)] 
    
    out_fectures = in_feactures/2 
    for _ in range(2):
      model += [ nn.nn.Conv2d(in_feactures, out_fectures),3 stride=2,padding=1, output_padding=1),
                 nn.InstanceNorm2d(out_fectures),
                 nn.ReLU(True) 
                ] 
      in_feactures = out_fectures
      out_fectures = in_feactures//2 

      model += [ nn.RefectionPad2d(3),
                 nn.Conv2d(64, output_nc, 7),
                 nn.Tanh()
                ]
      
      self.model = nn.Sequential(*model)```