WEBVTT

00:00.270 --> 00:02.590
Hola y bienvenidos a este tutorial de Python.

00:02.820 --> 00:08.730
Muy bien, así que hoy vamos a hacer la función de actualización que actualizará todo lo que hay hasta la

00:08.850 --> 00:12.240
fecha tan pronto como el ojo llegue a un nuevo estado.

00:12.510 --> 00:16.140
Entonces, cuando llega a una nueva etapa, sabes que debemos actualizar la acción.

00:16.200 --> 00:19.320
El último en realidad es la nueva acción que acaba de jugarse.

00:19.530 --> 00:22.630
Pero también la última fecha que se convierte en el nuevo estado.

00:22.680 --> 00:27.450
Y finalmente, la última palabra que se convierte en la nueva palabra que obtenemos cuando jugamos la acción.

00:27.480 --> 00:31.480
Entonces esa es la ruta lógica que ocurre justo después de seleccionar una acción.

00:31.530 --> 00:35.100
Necesitamos actualizar todos los elementos de las transiciones.

00:35.310 --> 00:37.370
Y, por supuesto, obtendrás una nueva transición.

00:37.420 --> 00:40.300
Entonces, tendremos que agregar esta nueva transición a la memoria.

00:40.350 --> 00:46.200
Y finalmente también actualizaremos o recompensaremos la ventana que usted conoce para estar atentos a la evolución

00:46.200 --> 00:49.460
de cómo va la capacitación y cómo va la exploración.

00:49.680 --> 00:55.380
entre la inteligencia artificial que estamos implementando en este momento en nuestro mapa, porque si regresamos a

00:55.530 --> 01:01.650
nuestro mapa, recuerda que hay una función de actualización de Beiji en la clase de juego y ahí

01:01.650 --> 01:08.580
es donde estábamos haciendo el juego con el auto y definiendo cómo el auto debería ser castigado cuando comete un error.

01:08.580 --> 01:12.940
Pero lo más importante para ti es que ahora podamos establecer una conexión

01:13.170 --> 01:19.140
Pero en esta clase de juego notamos esta función de actualización y en esta función de

01:19.500 --> 01:24.700
actualización notamos esta acción de línea porque la última actualización del cerebro funcionó menos.

01:24.900 --> 01:28.410
Y en realidad esto es exactamente lo que estamos a punto de hacer.

01:28.410 --> 01:36.300
Estamos a punto de hacer esta función de actualización que tomará la última palabra y la última señal para obtener la

01:36.300 --> 01:37.860
siguiente acción para jugar.

01:37.860 --> 01:41.640
Entonces, no solo actualizará todos los diferentes elementos de la transición.

01:41.910 --> 01:48.390
que estamos a punto de hacer para seleccionar la dirección para jugar además de hacer todas las actualizaciones.

01:48.390 --> 01:55.920
Pero más que nada jugaremos la acción que deberíamos jugar cuando recibamos la última palabra y la última señal y,

01:55.920 --> 02:02.400
por supuesto, en esta función de actualización utilizaremos la función de selección de acción que acabamos de

02:02.400 --> 02:07.740
implementar antes de integrar la función de acción seleccionada en función de actualización futura

02:07.860 --> 02:11.200
Entonces eso es realmente importante para hacer esta conexión con el mapa en este momento.

02:11.310 --> 02:18.480
Lo que estamos a punto de hacer es, finalmente, la conexión entre nuestro ojo y el juego, el juego que

02:18.480 --> 02:19.750
hacemos en esta clase.

02:19.770 --> 02:24.030
Y entonces, lo que podemos hacer ahora es tomar esta actualización directamente.

02:24.060 --> 02:29.970
último, estábamos menos señal porque esa es en realidad la función que haremos con estos dos argumentos aquí.

02:29.970 --> 02:30.430
Por

02:30.720 --> 02:38.530
Y al igual que un cerebro de recordatorio rápido es nuestro objeto AI, es el objeto de la clase Dejuan.

02:38.540 --> 02:45.690
Entonces, lo que vamos a hacer ahora es copiar esta señal de actualización con menos palabras y esa

02:45.690 --> 02:48.390
será nuestra próxima función que estamos haciendo.

02:48.480 --> 02:54.120
Y por lo tanto y pegar eso aquí, solo para tener cuidado, me gustaría dar algunos nombres diferentes

02:54.120 --> 02:56.190
a los nombres que tenemos aquí.

02:56.200 --> 03:00.820
Sabes que tenemos la última palabra aquí y no quiero confundir esta última palabra con esta.

03:00.900 --> 03:02.060
Eso puede ser peligroso.

03:02.220 --> 03:06.100
Así que voy a reemplazar la última palabra aquí por palabra.

03:06.390 --> 03:13.880
Y por cierto, para menos señal, simplemente pongamos señal o incluso nueva señal para especificar que sabes que queremos medir

03:13.920 --> 03:18.900
eso cuando alcances un nuevo estado y, por lo tanto, obtener una nueva señal.

03:18.900 --> 03:26.100
Pero luego, por supuesto, esta palabra aquí va a ser la última recompensa que tenemos aquí.

03:26.280 --> 03:32.400
Sabes que cuando te acercas a un poco de arena o peor te acercas demasiado a un borde del mapa, ahí es

03:32.670 --> 03:34.130
donde definimos la última palabra.

03:34.200 --> 03:39.400
Esta última palabra va a ser la entrada de la función de actualización, por eso tenemos la última palabra aquí.

03:39.600 --> 03:43.660
Pero justo aquí estoy dando otro nombre para la discusión.

03:43.710 --> 03:47.640
Queremos no confundirlo con la última palabra aquí.

03:47.640 --> 03:50.160
De acuerdo, esta es la función de actualización.

03:50.310 --> 03:54.090
Y ahora vamos a entrar y hagamos estas dos cosas.

03:54.090 --> 03:58.970
Esa es la información de todos los elementos de nuestra transición y, por supuesto, seleccione la acción.

03:59.290 --> 04:01.670
OK, entonces, ¿qué necesitamos actualizar primero?

04:01.950 --> 04:06.760
Bueno, como has entendido, queremos establecer una fecha para alcanzar cualquier estado.

04:06.840 --> 04:12.800
Entonces, lo primero que actualizaremos es, obviamente, esta noticia de que esa es la noticia a la que estamos llegando.

04:12.840 --> 04:17.340
Así que voy a llamar a este nuevo estado estado nuevo y luego lo hará.

04:17.340 --> 04:19.810
Entonces, ¿cómo podemos obtener este nuevo estado?

04:20.040 --> 04:25.460
Bueno, por supuesto, eso depende de la señal de la nueva señal que los sensores acaban de detectar.

04:25.830 --> 04:32.760
Y como recordatorio, el estado es la señal en sí misma compuesta de las tres señales que los

04:32.760 --> 04:37.470
sensores señalan una señal para señalar tres más orientación y menos orientación.

04:37.530 --> 04:38.600
Ese es nuestro estado.

04:38.610 --> 04:42.470
Así que asegúrese de entender que la señal es el estado.

04:42.660 --> 04:46.160
Pero ahora mismo es una lista simple de cinco elementos.

04:46.200 --> 04:51.540
esta será la entrada para hacer todo ese trabajo, recuerde que debemos convertirlo en un sensor de antorcha.

04:51.540 --> 04:52.200
Y como

04:52.490 --> 04:54.960
Así que eso es exactamente lo que vamos a hacer en este momento.

04:54.960 --> 05:03.910
Vamos a tomar nuestra biblioteca de antorchas y luego tomar la clase de tensor allí donde vamos, que convertirá nuestra nueva

05:04.450 --> 05:12.420
señal en una antorcha más densa, entonces es mejor asegurarse de que todos los elementos de la antorcha para

05:12.420 --> 05:19.650
responder sean flotantes, así que voy a hacer una conversión de tipo para convertirlos en carrozas como esta.

05:19.900 --> 05:24.500
Y finalmente, intenta obtener un reflejo de lo que tenemos que hacer a continuación.

05:24.530 --> 05:29.590
Por supuesto, crear ese motor falso para agregar diamantes y corresponder al lote y

05:29.590 --> 05:37.080
lo hacemos, por supuesto, con la función de compresión a la que tenemos que poner el índice de este gran diamante.

05:37.100 --> 05:40.210
Y queremos para el lote que es cero.

05:40.770 --> 05:41.320
Todo bien.

05:41.320 --> 05:47.110
Y ahora tenemos nuestros nuevos estados compuestos por las tres señales de los tres sensores más la

05:47.110 --> 05:54.290
orientación menos la orientación y, por supuesto, eso dependerá de la nueva señal que recibamos con esta función de actualización.

05:54.400 --> 05:57.940
Justo en este momento, la última señal, recibimos las tres señales.

05:57.940 --> 06:04.450
Entonces, además, menos o además y como recordatorio, las tres señales son la densidad del sensor detectado

06:04.720 --> 06:06.490
alrededor de los sensores.

06:06.490 --> 06:06.940
Todo bien.

06:06.970 --> 06:13.710
Así que obtuvimos una nueva etapa, lo que significa que llegamos a la nueva etapa y ahora tenemos que hacer la próxima actualización.

06:13.750 --> 06:16.440
Entonces, según usted, ¿qué necesitamos actualizar ahora?

06:16.660 --> 06:22.320
Cuál sería la cosa lógica para salir ahora mismo después de alcanzar este nuevo estado.

06:22.630 --> 06:25.940
Bueno, lo que necesitamos para salir ahora es la memoria.

06:25.960 --> 06:27.010
Porqué es eso.

06:27.010 --> 06:34.200
Es porque en cada momento t una transición se compone del estado actual Estey al día siguiente como tipis

06:34.220 --> 06:37.660
cuando la recompensa es arti y la acción 80.

06:37.860 --> 06:44.020
y ya tenemos 80 y acabamos de obtener el último elemento de la transición Estep más uno.

06:44.020 --> 06:47.540
Y ahora mismo ya tenemos S-T, ya tenemos nuestro equipo

06:47.590 --> 06:55.720
Entonces, al obtener este nuevo estado tan profundo como uno, estamos obteniendo una nueva transición de la memoria y, por lo tanto,

06:55.720 --> 07:01.910
tenemos que agregar esta nueva transición a la memoria porque esa es simplemente nuestra próxima transición.

07:01.930 --> 07:03.980
Entonces es por eso que tenemos que recordar eso ahora.

07:04.120 --> 07:10.990
Y, por lo tanto, lo que voy a hacer es tomar mi objeto de memoria creado a partir de la

07:10.990 --> 07:17.130
clase de memoria de reproducción y, por lo tanto, tomaré la memoria propia para referirme al objeto.

07:17.160 --> 07:22.700
Pero dado que estoy usando el yo, tengo que incluir el yo en el de esa función.

07:22.950 --> 07:25.440
Entonces ahora puedes ver para qué es este yo.

07:25.550 --> 07:32.600
Siempre que usa una variable que creó e inicializó en la función init a esa memoria.

07:32.600 --> 07:33.960
Y ahora lo hicimos

07:34.190 --> 07:36.950
Y de acuerdo a usted, cómo vamos a actualizar eso.

07:37.160 --> 07:41.290
Bueno, la buena noticia es que ya hicimos una función para hacer eso.

07:41.300 --> 07:46.990
Es la función de inserción que prohibe un evento o una transición a la memoria.

07:47.190 --> 07:49.060
Entonces eso es exactamente lo que vamos a usar ahora.

07:49.070 --> 07:55.460
inserción para escribir nuestra nueva transición que acabamos de hacer a la memoria y, por lo tanto, aquí no estoy

07:55.760 --> 08:01.820
tomando la misma medida porque vamos a usar el método y, por lo tanto, podemos usar ese impulso directamente.

08:02.320 --> 08:04.200
Vamos a usar la función de

08:04.280 --> 08:10.010
Y primero voy a agregar la transición a esta nueva transición que acabamos de recibir y que es la

08:10.010 --> 08:10.780
primera fecha.

08:10.850 --> 08:14.010
Así que auto esa última fecha.

08:14.270 --> 08:18.680
Así que eso es S-T. Eso es exactamente lo que ya existe.

08:18.680 --> 08:23.620
Entonces, el siguiente elemento de esta transición es, por supuesto, el nuevo estado que acabamos de alcanzar.

08:23.840 --> 08:29.720
Y por lo tanto, dado que no es viable del objeto que hemos creado e inicializado en esta función

08:30.080 --> 08:31.470
init, no nos situamos aquí.

08:31.580 --> 08:39.940
Colocamos directamente el Newstead, entonces el siguiente elemento de la transición es la acción y decimos que ya tenemos la última

08:39.940 --> 08:43.690
sección, que es este yo, la última acción aquí.

08:43.840 --> 08:45.320
Entonces, por supuesto, es igual a cero.

08:45.350 --> 08:50.050
Pero luego, por supuesto, se actualizará con la función de selección de acción.

08:50.170 --> 08:51.190
Pero ese es este.

08:51.190 --> 08:55.620
Entonces, es el yo la última acción.

08:55.840 --> 08:57.120
Pero ahora ten cuidado

08:57.190 --> 09:01.540
Los elementos que se incluyeron en esta transición deberían ser respuestas quemadas.

09:01.870 --> 09:03.860
Como puede ver, ese es el caso de la última fecha.

09:03.880 --> 09:05.200
Es un sensor de antorcha

09:05.350 --> 09:07.860
El nuevo estado también es una respuesta incendiada.

09:07.900 --> 09:12.050
Y así debe ser lo mismo para la acción y luego la recompensa, por supuesto.

09:12.190 --> 09:17.320
Pero ahora vas a pensar cómo puede ser una respuesta incendiada, considerando que es simplemente un número.

09:17.410 --> 09:20.700
Usted sabe que la acción es 0 1 o 2.

09:20.890 --> 09:22.370
Pero de hecho eso no es un problema.

09:22.390 --> 09:28.640
Todavía podemos convertir esta variable 0 1 o 2 en un sensor de antorcha.

09:28.660 --> 09:31.530
Esto será lo que llamamos un tensor largo.

09:31.540 --> 09:36.910
El largo es un tipo y ese es el tensor que contendrá un entero porque la última

09:36.910 --> 09:39.660
acción es un entero, es 0 1 o 2.

09:39.670 --> 09:47.650
Entonces, lo que vamos a tomar ahora es nuestra biblioteca antorcha, entonces vamos a tomar la larga clase de

09:48.190 --> 09:53.470
tensor largo que creará un objeto que será la no tenencia misma.

09:53.710 --> 10:00.370
Y al tomar esta última función de acción como entrada, creará este objeto tensor largo pero aún contendrá

10:00.370 --> 10:08.590
0 1 o 2 en un objeto tensor largo y eso es solo para ser consistente con la transición que solo contiene

10:08.830 --> 10:14.070
tensores porque estamos trabajando con PI torch y estamos trabajando con una red neuronal.

10:14.170 --> 10:18.480
Entonces tenemos que trabajar con sensores para que podamos esperar mucho tiempo para responder.

10:18.580 --> 10:20.780
Y una última conversión para hacer.

10:20.860 --> 10:27.520
Debemos estar seguros de que lo que hay dentro de esta respuesta larga es un número entero y para asegurarnos

10:27.520 --> 10:34.000
de que incluso si ya sabemos que la última acción es 0 1 o 2 para asegurarnos de que vamos

10:34.000 --> 10:39.310
a hacer esta conversión de tipo int nuevamente, convertimos nuestro la última acción en un entero.

10:39.310 --> 10:46.450
Ahí vamos y luego debemos poner esa acción desinteresada entera entre paréntesis aquí, de modo que ahora tenemos

10:46.450 --> 10:52.810
un tensor largo de un elemento que será esta última acción 0 o 1 o 2.

10:52.810 --> 10:59.880
El punto clave es que así es como convierte un número simple de cero uno o dos en un tensor con torche.

11:00.060 --> 11:00.360
Todo bien.

11:00.360 --> 11:06.820
Y finalmente, el último elemento de la transición y esa es, por supuesto, la última palabra que recibimos.

11:06.880 --> 11:12.980
Esa es exactamente la última palabra de voleibol que creamos en cualquier función que se inicializó a cero.

11:13.110 --> 11:19.720
Pero luego, por supuesto, se actualiza aquí en este código cuando pasamos a algún sentido que es una palabra negativa o

11:19.770 --> 11:24.020
si nos alejamos más de la meta que es nuevamente una recompensa negativa.

11:24.180 --> 11:30.090
Si nos acercamos a la meta, esa es una recompensa positiva y el peor castigo si nos acercamos demasiado a

11:30.090 --> 11:34.080
una orilla del mapa. Bueno, esa es una terrible palabra negativa menos una.

11:34.290 --> 11:36.190
Y eso es a.

11:36.260 --> 11:40.810
Así que agreguemos este último elemento de la transición autodirigir la palabra.

11:41.060 --> 11:47.660
Así que estoy copiando este pegado aquí y ahora tenemos que hacer otra conversión que, por supuesto, será

11:47.750 --> 11:53.570
exactamente la misma ya que la palabra no es un número entero sino un número flotante.

11:53.780 --> 12:00.350
Simplemente haremos una antorcha que tensor la conversión, pero sin eso mantendrá los paréntesis aquí porque primero sabremos que tenemos que

12:00.350 --> 12:06.200
poner el número en una lista y luego esta lista irá y se pondrá la antorcha en la clase,

12:06.200 --> 12:11.510
pero no tenemos para hacer eso en la conversión porque la última palabra es un número flotante.

12:11.510 --> 12:21.400
Entonces, lo que vamos a hacer es simplemente agregar aquí que el tensor de punto de la antorcha ha quemado un tensor y luego paréntesis entre paréntesis.

12:21.680 --> 12:27.470
Y vamos a cerrar los corchetes aquí y cerramos el paréntesis.

12:27.470 --> 12:28.820
Aquí vamos.

12:28.820 --> 12:35.180
Entonces, para resumir, ¿qué dijiste que acabamos de alcanzar y en la palabra que observamos un nuevo evento de transición

12:35.540 --> 12:37.150
que agregamos a la memoria?

12:37.550 --> 12:44.240
Y esta transición contiene la última fecha y ve el nuevo estado como tipis cuando la última

12:44.540 --> 12:47.640
acción reproduce 80 y la última palabra Archie.

12:48.020 --> 12:48.390
Todo bien.

12:48.440 --> 12:51.220
Y ahora vamos con nuestro recuerdo de las fechas.

12:51.410 --> 12:55.710
Tomemos un descanso rápido y nos ocuparemos de la próxima actualización en el próximo tutorial.

12:55.970 --> 12:57.440
Hasta entonces I.
