WEBVTT

00:00.420 --> 00:04.730
Hola y bienvenidos al último paso de esta parte uno construyendo el.

00:04.860 --> 00:10.500
Ahora, lo único que tenemos que hacer es hacer que esta sea la función de Ford que propagará

00:10.500 --> 00:16.650
la señal desde el principio, cuando el cerebro esté obteniendo la imagen hasta el final cuando coloque la acción, así

00:16.650 --> 00:22.260
que vamos a hacer esto. toda la función y ese va a ser nuestro último paso antes de

00:22.260 --> 00:26.710
pasar a formar parte de la formación de nuestra IA con kulang convolucional profundo.

00:26.890 --> 00:28.080
Entonces, hagamos esto.

00:28.080 --> 00:34.470
Vamos a tomar la llamada a función que en realidad es similar a la función init que es una

00:34.470 --> 00:38.760
función existente, pero esta vez la usamos para llamar a otras funciones.

00:38.790 --> 00:43.170
Los que hicimos antes porque saben que vamos a utilizar la función de avance del

00:43.290 --> 00:45.490
cerebro y la función de puerto del cuerpo.

00:45.630 --> 00:50.270
Y ahora estamos usando esta función para básicamente llamar a estas funciones.

00:50.550 --> 00:53.160
Así que llamar va a tomar dos argumentos.

00:53.160 --> 00:54.330
El primero es uno mismo.

00:54.330 --> 01:00.220
Por supuesto, el objeto y el segundo argumento que según usted va a ser.

01:00.360 --> 01:02.910
Bueno, estamos haciendo toda la propagación esta vez.

01:02.910 --> 01:08.460
supuesto, las imágenes de entrada porque, por supuesto, ese es el punto de partida cuando la IA está jugando el juego.

01:08.460 --> 01:10.860
Entonces, lo que queremos tomar como entrada son, por

01:10.860 --> 01:16.080
Primero visualiza las imágenes del juego, luego propaga las señales en el cerebro y luego

01:16.080 --> 01:17.180
reproduce la acción.

01:17.190 --> 01:20.130
Por lo tanto, el segundo argumento va a ser entradas.

01:20.610 --> 01:24.740
Y ahora estamos listos para hacer toda esta propagación.

01:24.810 --> 01:26.220
Así que hagámoslo de nuevo.

01:26.220 --> 01:31.900
Entonces, el primer paso donde es el primer paso es recibir las imágenes de entrada del juego.

01:32.190 --> 01:38.010
que tenemos que formatearlas en una estructura especial y la estructura es, por supuesto, una estructura de antorcha.

01:38.010 --> 01:42.840
Y dado que estas imágenes van a entrar en la red neuronal Bueno, puedes imaginar

01:42.840 --> 01:48.420
Entonces, lo primero que sucederá es que convertiremos estas imágenes en una matriz de árbitros, luego

01:48.420 --> 01:55.320
la convertiremos en un tensor de antorcha y, finalmente, pondremos el tensor de la antorcha dentro de una variable de

01:55.500 --> 01:58.260
antorcha que contendrá tanto el tensor como un degradado.

01:58.350 --> 02:03.780
Eso es para que nuestros gráficos dinámicos calculen de manera muy eficiente los gradientes más adelante, Kattie es más rápido

02:03.780 --> 02:04.460
en este sentido.

02:04.620 --> 02:06.200
Entonces ese es nuestro primer paso.

02:06.270 --> 02:12.130
imágenes, podrán ingresar a la red neuronal y entonces haremos toda la propagación de las señales.

02:12.360 --> 02:16.320
Y luego, una vez que obtengamos el formato correcto de nuestras

02:16.380 --> 02:20.340
Primero, hagamos esto para convertir la imagen al formato correcto.

02:20.430 --> 02:23.050
Entonces nuestras imágenes son para entradas.

02:23.220 --> 02:26.780
Ahora vamos a crear una nueva variable a la que estoy llamando entrada.

02:26.820 --> 02:30.470
Esa es la entrada real de la red neuronal y esta entrada.

02:30.510 --> 02:31.760
Dónde va a ser.

02:31.920 --> 02:34.490
Bueno, primero tenemos que tomar nuestras entradas.

02:34.530 --> 02:36.650
Esa es nuestra imagen original.

02:36.870 --> 02:42.190
Luego, como dijimos, queremos convertir estas imágenes en matrices Nampa.

02:42.330 --> 02:49.260
Entonces para hacer esto simplemente no podemos tomar ninguno por el cual tenga un atajo y luego la matriz de funciones.

02:49.500 --> 02:52.850
Entonces ponemos en el paréntesis de la matriz de funciones.

02:52.890 --> 02:53.340
Aquí vamos.

02:53.340 --> 02:55.940
Ahora se convierte en algo y por matrices.

02:56.190 --> 03:02.790
Pero dado que las celdas de las matrices del teclado numérico contendrán los píxeles, en realidad es más seguro

03:02.790 --> 03:04.230
especificar el tipo flotante.

03:04.310 --> 03:11.040
Es mejor asegurarse de tener algunas carrozas en este momento para asegurarnos de que podamos usar esa carroza.

03:11.090 --> 03:12.690
Lamento escuchar.

03:12.720 --> 03:15.390
Muy bien, así que ahora todavía tenemos un árbitro.

03:15.540 --> 03:17.330
Pero con la tableta.

03:17.720 --> 03:24.150
Está bien y esa es otra razón por la que los tensores son, por definición, matrices de un solo tipo.

03:24.270 --> 03:28.060
Y entonces elegimos el tipo simple para ser un flotador flotante 32.

03:28.060 --> 03:28.350
Todo bien.

03:28.350 --> 03:34.440
Ahora que tenemos nuestro aumento no bio, el siguiente paso es convertirlo en un sensor de

03:34.440 --> 03:37.990
tortuga y para hacerlo podemos utilizar, por ejemplo, la antorcha.

03:38.070 --> 03:45.380
Y luego desde la función no piloto de subrayado que convertirá eso en un sensor de antorcha.

03:45.420 --> 03:46.200
Aquí vamos.

03:46.210 --> 03:52.320
Y ahora el último paso es poner estos sensores de antorcha en una variable de antorcha que contiene tanto el tensor

03:52.320 --> 03:53.230
como el acuerdo.

03:53.400 --> 04:02.010
Y usted sabe cómo hacerlo, por supuesto, tomamos nuestra clase variable porque en realidad todo lo que está dentro de esta variable

04:02.010 --> 04:05.530
es en realidad la entrada de la clase variable.

04:05.760 --> 04:11.400
Pero quería mostrarte eso de esta manera porque sabes que comenzamos con nuestras imágenes de entrada,

04:11.400 --> 04:15.890
luego las convertimos en matrices numeradas y luego en antorchas y mañana.

04:16.170 --> 04:17.220
Y ahora estamos bien.

04:17.220 --> 04:23.370
Se les permite ingresar a la red neuronal que es primero los ojos del ojo y luego a las

04:23.370 --> 04:25.770
capas completamente conectadas para conducir a las predicciones.

04:26.220 --> 04:30.340
Entonces, hablando de los ojos, eso es exactamente lo que vamos a hacer ahora.

04:30.480 --> 04:37.280
Vamos a propagar estas imágenes permitidas ahora en los ojos de los ojos que están a través de

04:37.290 --> 04:38.720
las tres capas convolucionales.

04:38.850 --> 04:41.620
Y para hacer esto, verás ahora cómo es tan simple.

04:41.640 --> 04:46.290
Eso es porque ya tenemos nuestro cerebro en nuestro cuerpo desde la función init.

04:46.320 --> 04:56.190
Simplemente necesitamos llevar nuestro cerebro a ese cerebro y aplicar este cerebro a las imágenes de entrada y eso propagará las cosas a

04:56.190 --> 04:59.830
la función de alimentos aquí desde el cerebro.

05:00.430 --> 05:06.190
Eso propagará las señales dentro del cerebro y dado que la función directa del cerebro devuelve las señales

05:06.520 --> 05:13.600
de salida de que las neuronas de la capa de salida contienen los valores de Q. Bueno este auto la entrada del

05:13.610 --> 05:19.030
cerebro aquí devolverá esta señal de salida y por lo tanto vamos a poner aquí, ya sea

05:19.090 --> 05:26.120
que se convierta en una variable y lo llamemos de manera muy simple, esta salida es la señal de salida del

05:26.120 --> 05:26.690
cerebro.

05:26.930 --> 05:31.970
para hacer esto vamos a usar la segunda función de reenvío del cuerpo y hacer esto.

05:31.970 --> 05:37.990
Y ahora que tenemos la señal de salida del cerebro, tenemos que propagar esta señal de salida al cuerpo y

05:38.030 --> 05:46.370
Simplemente necesitamos tomar nuestro cuerpo y aplicarlo a la salida, por supuesto, porque la función Ford del cuerpo

05:46.370 --> 05:50.600
toma como entrada las señales de salida del cerebro.

05:50.660 --> 05:55.880
Así que eso es exactamente lo que produce ahora y devuelve las acciones.

05:56.000 --> 05:58.080
Y por lo tanto, ya que devuelve las acciones.

05:58.380 --> 06:03.530
Bueno, aquí vamos a agregar acciones para causar ese mismo resultado.

06:03.920 --> 06:09.380
y luego desde el cerebro hasta la primera utilizando la función de forma del cerebro que

06:09.380 --> 06:15.410
nos lleva y colocamos las imágenes de entrada y luego las propagamos al cerebro para retener los valores clave.

06:15.410 --> 06:19.830
Muy bien, ahora puedes ver que simplemente propagamos las señales dentro del cerebro

06:20.240 --> 06:25.400
Y luego propagamos esta señal de salida en el cuerpo donde está la función de avance de nuestro cuerpo

06:25.520 --> 06:26.900
para que la acción funcione.

06:26.900 --> 06:32.300
Y ahora, lo único que nos queda por hacer es la última línea

06:32.300 --> 06:34.510
de código de esta parte uno.

06:34.760 --> 06:39.370
Tenemos que devolver la acción para jugar y eso son acciones.

06:39.530 --> 06:45.020
acciones tienen que socavar el formato y tenemos que convertirlas de nuevo por derecho y para hacerlo

06:45.260 --> 06:51.660
vamos a tomar la estructura de datos de estas acciones y luego agregar aquí la función no piloto y luego continuar.

06:51.890 --> 06:53.840
Sin embargo, en este momento las

06:53.840 --> 06:56.780
Ahora tenemos las acciones que convertimos en el formato correcto.

06:56.780 --> 06:58.040
Así que felicitaciones.

06:58.040 --> 07:00.660
Ahora hemos terminado con esta primera parte 1.

07:00.770 --> 07:03.410
Construimos la IA en tres pasos.

07:03.410 --> 07:06.860
Primero hicimos que el cerebro segundo hiciéramos el cuerpo.

07:06.860 --> 07:13.430
Y tercero, reunimos el cerebro en el cuerpo y propagamos toda la señal desde los ojos hasta el momento

07:13.430 --> 07:15.130
en que jugamos la acción.

07:15.560 --> 07:17.100
Entonces ese es un primer paso hecho.

07:17.120 --> 07:22.200
Eso fue un gran paso, pero ahora, como usted entendió, construimos una AI AI, pero sigue siendo estúpida.

07:22.220 --> 07:24.110
Necesitamos entrenarlo para ser inteligente.

07:24.170 --> 07:29.030
Así que tenemos que entrenarlo para que hagamos lo que queríamos hacer y para hacer esto vamos a

07:29.030 --> 07:34.100
usar la palabra "hacer" entornos que conoces porque es aprender del mundo al ser reforzado cuando obtiene una

07:34.100 --> 07:34.690
buena recompensa.

07:34.760 --> 07:40.610
Y al ser castigado o debilitado cuando se está pronunciando una mala palabra, es allí donde entrará en juego

07:40.610 --> 07:41.670
el aprendizaje de cue.

07:41.690 --> 07:47.510
Y eso es exactamente lo que haremos en esta parte para entrenar a la vista con un profundo aprendizaje Q convolucional.

07:47.510 --> 07:50.270
No puedo esperar para empezar y hasta entonces.
