1
00:00:04,940 --> 00:00:11,960
En esta lección crearás tu primer red neuronal

2
00:00:11,960 --> 00:00:14,480
y la utilizarás para resolver un problema de regresión.

3
00:00:15,540 --> 00:00:15,720
Comencemos.

4
00:00:18,320 --> 00:00:20,840
Vamos a crear nuestra primera red neuronal.

5
00:00:21,240 --> 00:00:22,280
Y para comenzar simple,

6
00:00:22,400 --> 00:00:24,120
resolveremos el mismo problema

7
00:00:24,120 --> 00:00:27,500
que resolvimos en el ejercicio de regresión lineal con SKLearn,

8
00:00:27,900 --> 00:00:30,060
pero ahora lo haremos con una red neuronal.

9
00:00:30,700 --> 00:00:32,720
Para eso utilizaremos TensorFlow,

10
00:00:33,300 --> 00:00:37,520
una biblioteca de Machine Learning que nos permite crear redes neuronales.

11
00:00:38,040 --> 00:00:43,760
TensorFlow junto con PyTorch son de las bibliotecas más utilizadas en la industria para Deep Learning.

12
00:00:44,280 --> 00:00:49,080
En mi experiencia, TensorFlow es más fácil para aprender y practicar los conceptos iniciales,

13
00:00:49,500 --> 00:00:52,100
y después puedes decidir con qué biblioteca continuar.

14
00:00:52,100 --> 00:00:54,900
Comencemos creando un nuevo archivo,

15
00:00:55,240 --> 00:00:57,340
ya sea en Colab o Visual Studio Code.

16
00:00:58,040 --> 00:01:01,420
Le voy a poner de nombre PrimeraRedNeuronal.

17
00:01:02,460 --> 00:01:08,300
Y lo primero que necesitamos hacer es agregar el archivo que hicimos con los datos de Celsius a Fahrenheit.

18
00:01:09,080 --> 00:01:11,340
Voy a tomar el archivo y lo voy a cargar.

19
00:01:12,320 --> 00:01:13,160
Y ya lo tenemos aquí.

20
00:01:13,720 --> 00:01:15,760
Y al igual que en los otros proyectos,

21
00:01:15,940 --> 00:01:20,420
lo primero que tenemos que hacer es utilizar Pandas para poder importar el archivo.

22
00:01:20,420 --> 00:01:22,600
Import Pandas as pd.

23
00:01:23,040 --> 00:01:23,680
Y de igual manera,

24
00:01:23,900 --> 00:01:30,620
datos igual a pd.readcsv con nuestro archivo Celsius.csv.

25
00:01:31,480 --> 00:01:34,280
Vamos a ejecutar la celda y podemos hacer como antes,

26
00:01:34,560 --> 00:01:36,720
datos.head para ver los datos que tenemos.

27
00:01:37,200 --> 00:01:40,680
Y estos son nuestros simples datos de conversión de Celsius a Fahrenheit.

28
00:01:41,100 --> 00:01:42,820
Ahora, recordemos que para este ejercicio,

29
00:01:42,900 --> 00:01:43,680
que es bastante fácil,

30
00:01:43,820 --> 00:01:47,340
no estamos haciendo separación entre datos de entrenamiento y pruebas,

31
00:01:47,540 --> 00:01:47,720
etc.

32
00:01:47,720 --> 00:01:48,660
Nos vamos directo

33
00:01:49,240 --> 00:01:50,060
al entrenamiento.

34
00:01:50,340 --> 00:01:53,760
Entonces, vamos a hacer lo mismo definiendo nuestra variable x y y.

35
00:01:54,280 --> 00:01:55,120
Y en este caso,

36
00:01:55,320 --> 00:01:58,380
para la x, queremos obtener los datos de la columna Celsius.

37
00:01:58,720 --> 00:02:00,280
Podemos hacerlo de esta manera.

38
00:02:00,800 --> 00:02:02,800
datos.Celsius.

39
00:02:03,060 --> 00:02:05,140
Y si lo dejamos de esta manera y lo ejecutamos,

40
00:02:05,220 --> 00:02:08,100
nos está regresando un objeto de tipo Series de Pandas,

41
00:02:08,220 --> 00:02:10,920
pero queremos directamente el arreglo con los datos.

42
00:02:11,100 --> 00:02:16,500
Entonces, podemos escribir .values y podemos ver que nos regresa directamente el arreglo con los datos.

43
00:02:16,500 --> 00:02:24,040
Entonces, voy a utilizar esto como mi x y de igual manera lo voy a hacer para la y, solamente especificando Fahrenheit.

44
00:02:24,920 --> 00:02:28,400
Y ahora sí, nos vamos directo a programar nuestra red neuronal.

45
00:02:28,600 --> 00:02:30,440
Para eso, vamos a importar TensorFlow.

46
00:02:30,940 --> 00:02:33,280
Import TensorFlow as tf.

47
00:02:33,820 --> 00:02:39,280
Y como antes, escribimos modelo, solo que ahora, en lugar de crear uno de los modelos de SKlearn,

48
00:02:39,380 --> 00:02:40,580
vamos a utilizar TensorFlow.

49
00:02:41,260 --> 00:02:46,320
TensorFlow tiene muchas maneras de hacer redes neuronales porque hay muchos tipos.

50
00:02:46,760 --> 00:02:49,920
En específico, vamos a utilizar una biblioteca llamada Keras,

51
00:02:50,140 --> 00:02:51,240
que es parte de TensorFlow

52
00:02:51,240 --> 00:02:53,680
y sirve para hacer redes neuronales de manera sencilla.

53
00:02:54,040 --> 00:02:57,660
Y vamos a utilizar una llamada Secuencial y vamos a estar utilizando esta

54
00:02:58,180 --> 00:03:00,100
prácticamente en todo lo que queda del curso.

55
00:03:00,720 --> 00:03:01,640
Dentro de los paréntesis,

56
00:03:01,760 --> 00:03:05,000
necesitamos abrir una lista y aquí vamos a poner todas las

57
00:03:05,100 --> 00:03:07,620
capas que va a tener nuestra red neuronal.

58
00:03:07,620 --> 00:03:11,220
En este caso, vamos a hacer lo más simple posible.

59
00:03:11,660 --> 00:03:16,920
Solamente vamos a definir cuántas entradas queremos y cuántas neuronas van a ser el procesamiento.

60
00:03:17,340 --> 00:03:19,900
En el ejemplo que vimos de la decisión de ir al concierto,

61
00:03:20,040 --> 00:03:23,740
teníamos tres entradas y un solo perceptron o neurona.

62
00:03:24,120 --> 00:03:26,280
En este caso, que es de Celsius a Fahrenheit,

63
00:03:26,520 --> 00:03:29,600
tenemos solamente una entrada y también un perceptron que hará el procesamiento.

64
00:03:29,800 --> 00:03:32,400
Vamos a especificarlos aquí.

65
00:03:32,480 --> 00:03:39,120
Primero escribimos tf.keras.layers.input y aquí es donde vamos a especificar la entrada.

66
00:03:39,260 --> 00:03:43,400
Y lo único que tenemos que decirle es de qué forma es la entrada,

67
00:03:44,000 --> 00:03:44,680
especificando shape,

68
00:03:45,340 --> 00:03:46,580
igual y una tupla.

69
00:03:46,920 --> 00:03:48,740
Y simplemente ponemos uno coma.

70
00:03:49,000 --> 00:03:52,340
Con esto estamos especificando que tenemos solamente un dato de entrada

71
00:03:52,340 --> 00:03:54,020
y podemos especificarlo aquí.

72
00:03:54,400 --> 00:03:55,100
La entrada,

73
00:03:55,680 --> 00:03:56,840
los Celsius,

74
00:03:57,280 --> 00:03:57,620
un solo dato.

75
00:03:57,620 --> 00:03:57,780
Y

76
00:03:58,840 --> 00:04:01,240
después vamos a agregarle aquí una coma.

77
00:04:01,720 --> 00:04:06,540
Abajo vamos a definir tf.keras.layers.dense.

78
00:04:07,020 --> 00:04:09,100
Este dense es el tipo que queremos.

79
00:04:09,320 --> 00:04:11,120
Más adelante vamos a ver otros,

80
00:04:11,380 --> 00:04:15,040
pero por lo pronto vamos a estar utilizando el denso durante las primeras lecciones.

81
00:04:15,240 --> 00:04:18,160
Y especificamos cuántas unidades o neuronas queremos.

82
00:04:18,460 --> 00:04:21,360
En este caso, solo especificamos units igual a uno.

83
00:04:21,360 --> 00:04:24,800
Y en este caso esto es la salida.

84
00:04:25,320 --> 00:04:28,880
También es un dato los grados Fahrenheit.

85
00:04:32,280 --> 00:04:34,560
Una vez que tenemos listo el modelo,

86
00:04:34,820 --> 00:04:36,260
necesitamos compilarlo.

87
00:04:36,360 --> 00:04:42,980
Es un proceso en el que le decimos a TensorFlow algunos datos adicionales que necesita para realizar el entrenamiento.

88
00:04:43,600 --> 00:04:46,260
Específicamente le vamos a especificar dos optimizer,

89
00:04:46,500 --> 00:04:48,700
es decir, el optimizador y los,

90
00:04:49,000 --> 00:04:50,340
que es la pérdida que va a medir.

91
00:04:50,340 --> 00:04:54,040
Estos datos son importantes en redes neuronales,

92
00:04:54,540 --> 00:04:58,060
ya que hay muchas formas en las cuales se puede hacer el entrenamiento.

93
00:04:58,580 --> 00:04:59,680
En el caso, por ejemplo,

94
00:05:00,020 --> 00:05:02,940
de los algoritmos que estuvimos haciendo en Machine Learning,

95
00:05:03,020 --> 00:05:04,560
digamos clásico, no Deep Learning.

96
00:05:05,040 --> 00:05:08,040
Cada uno de los algoritmos tiene una forma distinta de trabajar.

97
00:05:08,500 --> 00:05:13,320
Y en el caso de las redes neuronales son tan agnósticas o genéricas que tenemos que especificárselo aquí.

98
00:05:13,320 --> 00:05:17,600
El optimizador que vamos a usar prácticamente durante todo el curso

99
00:05:17,620 --> 00:05:21,260
es uno llamado TF Keras Optimizers Adam.

100
00:05:21,940 --> 00:05:25,640
Este optimizador nos va a servir para que el modelo sepa qué proceso

101
00:05:25,640 --> 00:05:27,600
tiene que seguir durante el aprendizaje.

102
00:05:27,820 --> 00:05:30,020
Veremos más detalles de esto un poco más adelante,

103
00:05:30,180 --> 00:05:30,880
pero por lo pronto,

104
00:05:31,380 --> 00:05:35,640
tenemos que especificar Adam y en los paréntesis le agregamos un parámetro.

105
00:05:36,280 --> 00:05:38,220
Este parámetro es la tasa de aprendizaje.

106
00:05:38,420 --> 00:05:40,280
Podemos comenzar con algo como punto uno.

107
00:05:40,480 --> 00:05:43,340
Y en un momento veremos más detalles de este dato.

108
00:05:43,740 --> 00:05:44,320
Y finalmente,

109
00:05:44,680 --> 00:05:45,220
la pérdida.

110
00:05:45,340 --> 00:05:47,140
Podemos dejar de momento algo como Min,

111
00:05:47,720 --> 00:05:48,140
Quert,

112
00:05:48,640 --> 00:05:51,640
Error, que es muy similar a lo que vimos en la regresión lineal,

113
00:05:51,680 --> 00:05:53,180
donde tomábamos los residuales,

114
00:05:53,660 --> 00:05:54,920
los elevábamos al cuadrado

115
00:05:54,920 --> 00:05:56,880
y luego obteníamos toda la sumatoria.

116
00:05:57,100 --> 00:06:01,260
Y de esa manera podíamos medir el error o qué tan mal estaba la línea

117
00:06:01,260 --> 00:06:02,800
para después poder ajustar.

118
00:06:03,120 --> 00:06:05,120
Vamos a ejecutar esta celda

119
00:06:05,120 --> 00:06:08,260
y con esto ya podemos comenzar el entrenamiento directamente.

120
00:06:08,260 --> 00:06:14,520
Voy a agregar por aquí otra celda de código y esperamos un momento a que termine de procesar.

121
00:06:14,780 --> 00:06:16,600
Y me equivoqué un poco.

122
00:06:16,940 --> 00:06:19,200
Aquí debe de ser secuential,

123
00:06:19,460 --> 00:06:21,720
porque es en inglés, no en español.

124
00:06:22,320 --> 00:06:22,580
Y listo.

125
00:06:23,160 --> 00:06:25,040
Y en la siguiente celda vamos a hacer el entrenamiento.

126
00:06:25,280 --> 00:06:29,880
Podemos escribir algo como entrenamiento igual a modelo punto fit.

127
00:06:30,440 --> 00:06:32,280
Y aquí se parece también a los modelos anteriores.

128
00:06:32,280 --> 00:06:33,840
Especificamos la X,

129
00:06:34,540 --> 00:06:39,660
especificamos la Y y un dato bastante importante llamado épocas que se escribe EPOCS,

130
00:06:39,980 --> 00:06:41,440
E P O C H S.

131
00:06:42,100 --> 00:06:46,620
Y esto es cuántas vueltas completas le va a dar a nuestro set de datos,

132
00:06:46,740 --> 00:06:47,580
que en este caso tenemos,

133
00:06:47,800 --> 00:06:51,220
me parece, siete ejemplos de Celsius y Fahrenheit en el conjunto.

134
00:06:51,840 --> 00:06:52,960
Y durante cada época,

135
00:06:53,080 --> 00:06:54,020
una vez que termina,

136
00:06:54,060 --> 00:06:55,580
va a medir qué tan mal le fue.

137
00:06:56,020 --> 00:06:58,660
Se va a optimizar con el optimizador y va a dar una vuelta más,

138
00:06:58,660 --> 00:07:03,560
etc. Eso lo va a hacer mil veces hasta tratar de llegar al mejor resultado.

139
00:07:04,240 --> 00:07:08,840
Vamos a ejecutarlo y me dice que la X no está definida,

140
00:07:09,080 --> 00:07:09,900
pero la tengo aquí.

141
00:07:10,020 --> 00:07:11,620
Probablemente no ejecute esta celda,

142
00:07:12,140 --> 00:07:13,340
aunque ya la tengo ejecutada.

143
00:07:13,420 --> 00:07:16,740
Vamos a ejecutar nuevamente el entrenamiento y comienza.

144
00:07:16,840 --> 00:07:17,500
Y como puedes ver,

145
00:07:17,560 --> 00:07:19,760
nos dicen que época va a 120, 130.

146
00:07:20,160 --> 00:07:22,160
Y esta es la pérdida que está midiendo.

147
00:07:22,340 --> 00:07:25,760
Puedes verlo como los residuales donde está tratando de ajustarse.

148
00:07:25,900 --> 00:07:26,560
Entonces va bajando, bajando, bajando.

149
00:07:26,560 --> 00:07:30,620
Quiere decir que cada vez le está yendo mejor y va,

150
00:07:30,800 --> 00:07:35,760
por ejemplo, aquí en la época 600 y ya le queda prácticamente cero de pérdida.

151
00:07:35,900 --> 00:07:37,960
Es decir, está obteniendo un ajuste casi perfecto.

152
00:07:38,340 --> 00:07:44,600
Recordemos que este ejemplo es muy simple porque es tal cual una relación lineal entre los Celsius y los Fahrenheit.

153
00:07:44,880 --> 00:07:47,880
Entonces vamos a obtener un muy buen resultado muy fácilmente.

154
00:07:48,220 --> 00:07:48,980
Una vez que terminó,

155
00:07:49,400 --> 00:07:54,380
puedo venir aquí abajo y nos dice que ya terminó hasta la época 1000 con una pérdida prácticamente nula.

156
00:07:54,380 --> 00:07:56,480
Y

157
00:07:57,560 --> 00:08:04,300
vamos a agregar una celda para hacer una pequeña gráfica donde veamos cómo fue bajando esa pérdida a través del entrenamiento.

158
00:08:04,500 --> 00:08:08,380
Para eso voy a importar matplotlib.pyplot.

159
00:08:08,480 --> 00:08:10,540
Haz PLT para poder graficar.

160
00:08:11,000 --> 00:08:13,160
Aquí puse W por alguna razón.

161
00:08:13,300 --> 00:08:16,040
Debe de ser PIPLOT y vamos a escribir, por ejemplo,

162
00:08:16,900 --> 00:08:18,820
que queremos que en el eje X,

163
00:08:19,000 --> 00:08:22,060
X label, diga el número de la época.

164
00:08:22,060 --> 00:08:25,940
En el eje Y con Y label vamos a ponerle la

165
00:08:26,480 --> 00:08:27,920
magnitud de la pérdida.

166
00:08:28,400 --> 00:08:33,340
Y finalmente lo que queremos graficar tal cual viene en la variable entrenamiento.

167
00:08:33,540 --> 00:08:34,380
Escribimos PLOT

168
00:08:35,080 --> 00:08:36,280
y entrenamiento.

169
00:08:36,660 --> 00:08:40,020
Esta variable es la que definimos aquí arriba durante el entrenamiento.

170
00:08:40,220 --> 00:08:42,800
Pusimos modelo punto fit y el resultado lo guardamos aquí.

171
00:08:43,160 --> 00:08:46,260
Realmente es como un histórico del proceso de entrenamiento.

172
00:08:46,400 --> 00:08:49,480
Entonces tiene algunos datos que podemos tomar para graficar.

173
00:08:49,580 --> 00:08:55,780
Podemos escribir entrenamiento punto history para obtener la historia de la pérdida a través de todas las épocas.

174
00:08:56,400 --> 00:08:59,960
Y si lo ejecutamos nos debería de graficar algo como esto.

175
00:09:00,280 --> 00:09:02,100
Cuando apenas comenzó aquí abajo tenemos el

176
00:09:02,100 --> 00:09:03,720
número de épocas donde llegamos hasta 1000.

177
00:09:03,820 --> 00:09:06,180
Podemos ver que la pérdida era muy grande ya que empieza

178
00:09:06,180 --> 00:09:10,780
de manera aleatoria y la línea no se ajusta a la relación entre Celsius y Fahrenheit.

179
00:09:11,000 --> 00:09:12,300
Pero conforme fue avanzando,

180
00:09:12,720 --> 00:09:14,000
gracias al optimizador,

181
00:09:14,380 --> 00:09:16,580
fue bajando poco a poco hasta que alrededor aquí

182
00:09:16,580 --> 00:09:20,280
de las 600-800 llegó casi a cero y ya se quedó constante.

183
00:09:20,520 --> 00:09:22,400
Y con esto ya estamos listos para hacer

184
00:09:22,400 --> 00:09:23,360
nuestras predicciones.

185
00:09:23,480 --> 00:09:26,120
Vamos a poner por ejemplo algún dato de Celsius,

186
00:09:26,420 --> 00:09:28,480
digamos 123 y vamos a

187
00:09:28,480 --> 00:09:34,800
obtener la predicción escribiendo predicción igual a modelo punto predict y le debemos enviar aquí los

188
00:09:34,840 --> 00:09:36,780
grados Celsius para que haga la predicción.

189
00:09:37,200 --> 00:09:38,600
Finalmente vamos a imprimir

190
00:09:39,120 --> 00:09:40,840
algo como predicción

191
00:09:42,020 --> 00:09:48,740
los grados Celsius que especificamos Celsius son predicción y utilizamos el índice cero ya que

192
00:09:49,000 --> 00:09:51,020
predicción finalmente es un arreglo.

193
00:09:51,100 --> 00:09:53,700
Siempre las predicciones nos regresan un arreglo de una posición.

194
00:09:54,060 --> 00:09:58,180
Entonces vamos a obtenerla tal cual aquí en el índice cero y ponemos Fahrenheit.

195
00:09:58,880 --> 00:10:09,000
Y ya con esto lo ejecutamos y aquí nos hace la predicción 123 Celsius son 253.4 Fahrenheit y ese dato es correcto.

196
00:10:09,540 --> 00:10:14,900
Si ponemos por ejemplo en lugar de 123 ponemos 1230 y lo ejecutamos podemos ver que

197
00:10:14,900 --> 00:10:19,520
nos dice que son 2246.2131 Fahrenheit.

198
00:10:20,500 --> 00:10:24,480
Sin embargo en este caso estas decimales están de más y eso es

199
00:10:24,480 --> 00:10:27,120
algo interesante de las redes neuronales.

200
00:10:27,280 --> 00:10:30,280
Finalmente todo lo que está ajustando poco a poco a diferencia

201
00:10:30,280 --> 00:10:33,600
de la regresión lineal que logramos un ajuste prácticamente perfecto.

202
00:10:33,960 --> 00:10:34,760
Las redes neuronales se

203
00:10:34,940 --> 00:10:39,400
basan todo en aproximaciones por lo tanto es muy raro que consigamos algo perfecto.

204
00:10:39,640 --> 00:10:43,300
Siempre vamos a tener por ahí algunas decimales de más o de menos etcétera

205
00:10:43,880 --> 00:10:49,080
y pudiéramos hacer que sea todavía mejor y quede prácticamente perfecto agregando más neuronas a la red y

206
00:10:49,120 --> 00:10:52,420
haciendo otro tipo de cosas pero eso lo veremos un poco más adelante.

207
00:10:55,920 --> 00:11:00,640
Algo adicional que quiero mostrar aquí es que por ejemplo del modelo que hicimos podemos

208
00:11:00,920 --> 00:11:13,360
obtener las capas utilizando layers y en este caso quiero la capa 0 porque solamente tiene una capa de neuronas y vamos a imprimir algo llamado get weights es decir obtener los pesos que fueron calculados

209
00:11:14,300 --> 00:11:20,620
y nos da estos dos datos tenemos 1.8 y decimales y 31.9 y decimales.

210
00:11:21,060 --> 00:11:32,520
Algo aquí relevante que quiero mostrar es que el cálculo real para convertir Celsius a Fahrenheit es el siguiente

211
00:11:33,080 --> 00:11:38,420
C es decir los grados Celsius que recibimos por 1.8 más 32.

212
00:11:39,120 --> 00:11:42,140
Este es el cálculo real con el cual hacemos la conversión

213
00:11:42,720 --> 00:11:47,640
y si lo vemos a detalle es prácticamente como explicamos que funciona una neurona.

214
00:11:47,640 --> 00:11:58,680
Es decir donde se toma una entrada ponderada es decir una entrada multiplicada por un peso y finalmente al final del proceso le suma un sesgo y eso es el resultado.

215
00:11:59,300 --> 00:12:02,980
Después está la función de activación pero aquí no estamos utilizando entonces no es relevante.

216
00:12:03,440 --> 00:12:14,620
Pero lo que quiero mostrar aquí es que este 1.8 es prácticamente lo que la red neuronal a través de su proceso de optimización logró descifrar y de igual manera el más 32 también lo puso acá.

217
00:12:14,880 --> 00:12:20,580
Este es un caso muy especial porque la fórmula de conversión se parece demasiado a cómo

218
00:12:20,580 --> 00:12:25,040
funcionan las neuronas entonces por eso nos da esos datos tan exactos y el perceptron

219
00:12:25,040 --> 00:12:27,080
lo logra modelar perfectamente.

220
00:12:27,660 --> 00:12:33,540
Ahora la pregunta es cómo llegó a 1.8 y a 32 para las variables

221
00:12:33,920 --> 00:12:40,320
o parámetros y eso es gracias a algo llamado back propagation o propagación

222
00:12:41,020 --> 00:12:41,780
hacia atrás.

223
00:12:42,220 --> 00:12:47,760
Este es un proceso que en realidad usa muchas matemáticas y cálculo específicamente cálculo

224
00:12:47,760 --> 00:12:51,480
diferencial derivadas y algo llamado la regla de la cadena.

225
00:12:51,880 --> 00:12:53,200
Pero en resumen es el proceso que

226
00:12:53,400 --> 00:12:58,640
casi todas las redes neuronales actualmente utilizan durante su proceso de entrenamiento.

227
00:12:59,040 --> 00:13:03,900
En este caso nuestra red tiene solamente dos parámetros un peso y un sesgo pero muy pronto

228
00:13:03,900 --> 00:13:08,560
vamos a comenzar a trabajar con redes neuronales que tienen cientos o hasta miles de parámetros

229
00:13:08,820 --> 00:13:12,680
y todos estos comienzan inicializados de una manera totalmente aleatoria.

230
00:13:13,000 --> 00:13:14,880
Entonces cuando comienza toma los datos

231
00:13:15,340 --> 00:13:22,080
intenta predecir con los parámetros que tiene y ve qué tan mal le fue al modelo es decir se calcula su error

232
00:13:22,340 --> 00:13:25,740
específicamente con el hiperparámetro que le especificamos aquí.

233
00:13:26,360 --> 00:13:33,420
Finalmente se calcula la gradiente o las derivadas para ver qué tanto se debe actualizar cada peso y cada sesgo de la red

234
00:13:33,780 --> 00:13:36,660
uno por uno intentando mejorar los resultados.

235
00:13:37,320 --> 00:13:41,960
Si el error calculado fue grande los parámetros se van a estar ajustando mucho con cada vuelta

236
00:13:41,960 --> 00:13:44,020
pero si el error fue pequeño se ajusta poco.

237
00:13:44,300 --> 00:13:50,260
Y finalmente el optimizador en este caso Adam utiliza este dato la tasa de aprendizaje

238
00:13:50,340 --> 00:13:54,280
para tener más control sobre qué tanto se ajustan los parámetros en cada vuelta.

239
00:13:54,720 --> 00:13:58,520
Si lo dejamos muy pequeño la red va a tardar muchas épocas en aprender

240
00:13:58,520 --> 00:14:03,160
pero si lo dejamos muy grande cada vuelta hará ajustes muy grandes a los parámetros

241
00:14:03,160 --> 00:14:06,400
y va a estar batallando en llegar al mejor resultado posible.

242
00:14:06,840 --> 00:14:11,060
En resumen con esto hicimos nuestra primera red neuronal y vimos ya varias cosas.

243
00:14:11,240 --> 00:14:16,420
Entraremos a más detalles de varios de estos temas más delante conforme hagamos redes más complicadas

244
00:14:16,420 --> 00:14:21,900
pero solamente recordando que esto que vimos es una red de regresión ya que nos está calculando un dato

245
00:14:21,900 --> 00:14:26,040
continuo por ejemplo un número que puede ser tan grande como queramos.

246
00:14:26,480 --> 00:14:30,000
Sin embargo muy pronto trabajaremos también redes de clasificación.

247
00:14:33,420 --> 00:14:39,380
Ahora que creas tu primera red neuronal en la siguiente lección la utilizaremos para resolver un problema de clasificación.