WEBVTT

00:00.390 --> 00:02.710
Hola y bienvenidos a la especia Intertoto.

00:03.000 --> 00:07.800
Está bien, entonces en esta nueva sección de código vamos a implementar experiencia con el juego.

00:07.920 --> 00:13.850
Así que vamos a hacer una nueva clase que llamaremos memoria de repetición y que implementará la experiencia para

00:13.850 --> 00:16.700
jugar exactamente como viste en las conferencias de intuición.

00:16.890 --> 00:21.540
Pero primero démonos un recordatorio rápido sobre lo que es la repetición de experiencia.

00:21.540 --> 00:27.750
Así que sabes que toda esta inteligencia artificial se basa en los procesos de decisión de Markov y los

00:27.750 --> 00:31.840
procesos de decisión de Markov consisten en observar una serie de eventos.

00:32.010 --> 00:38.770
Así que los eventos son, por ejemplo, que van de un estado al siguiente y tipis uno.

00:39.060 --> 00:44.410
Pero si los eventos fueron así desde el día siguiente, están muy correlacionados con el estado actual.

00:44.550 --> 00:46.820
Bueno, a la red no le estaría yendo muy bien.

00:46.980 --> 00:52.710
Entonces para aquellos que vienen del curso de aprendizaje profundo eso es exactamente lo mismo que aprendimos nuestra serie de

00:52.710 --> 00:54.860
tiempo con solo un paso de tiempo.

00:55.020 --> 01:00.300
No aprendía nada porque un paso de tiempo no era suficiente para que un modelo

01:00.300 --> 01:03.070
aprendiera a entender las correlaciones a largo plazo.

01:03.090 --> 01:07.060
Así que es lo mismo aquí y es por eso que tenemos que implementar la repetición de la experiencia.

01:07.230 --> 01:08.230
Entonces, cómo funciona.

01:08.340 --> 01:13.960
Bueno, eso es muy simple en lugar de considerar solo el estado actual que es solo un estado en el

01:13.960 --> 01:14.640
tiempo t.

01:14.680 --> 01:16.830
Vamos a considerar más en el pasado.

01:16.830 --> 01:22.560
Así que exactamente como para los litios y por lo tanto nuestra serie de eventos no será tan.

01:22.560 --> 01:27.450
Y supongo que uno será, por ejemplo, los cien estados en el pasado.

01:27.450 --> 01:33.770
Entonces, como T-menos ciento ochenta menos 99 hasta menos-1 y luego S-T.

01:34.020 --> 01:40.830
que llamamos la memoria y es por eso que tenemos una memoria a largo plazo en lugar de una memoria a

01:40.830 --> 01:47.040
corto plazo o incluso debería decir una memoria instantánea y eso hace que todo el proceso funcione mucho mejor.

01:47.040 --> 01:49.950
En otras palabras, ponemos 100 transiciones menos en lo

01:50.310 --> 01:57.690
Y luego, una vez que creamos esta memoria de los últimos 100 eventos, simplificaremos que tome algunos

01:57.690 --> 02:02.300
lotes aleatorios de estas transiciones para hacer nuestra próxima actualización.

02:02.310 --> 02:09.270
Ese es nuestro próximo paso al seleccionar la siguiente sección y, por lo tanto, en esta clase de memoria de

02:09.270 --> 02:13.450
repetición que estamos implementando para la reproducción de experiencia haremos tres funciones.

02:13.530 --> 02:17.490
En primer lugar, la función habitual es el caso para cualquier clase.

02:17.520 --> 02:23.400
Y así en esta función definiremos las variables que se adjuntarán a las instancias futuras de la clase que

02:23.400 --> 02:27.210
son los objetos futuros que se crearán a partir de esta clase.

02:27.540 --> 02:32.790
Y de manera muy simple, estas variables serán la memoria de las 100 transiciones a 100 eventos.

02:32.970 --> 02:38.790
Y la capacidad que es el número 100 le invitará a probar una memoria más larga al aumentar

02:38.790 --> 02:39.550
la capacidad.

02:39.780 --> 02:46.170
Así que esa es la primera función en su función y luego realizaremos otras dos funciones, una función de

02:46.500 --> 02:51.050
inserción para asegurarnos de que la memoria nunca contenga más de 100 transiciones.

02:51.180 --> 02:57.150
Y para esto usaremos la capacidad simplemente haciendo una condición simple y luego eventualmente haremos

02:57.360 --> 03:03.300
la función simple y eso será por supuesto para probar algunas transiciones en esta memoria

03:03.390 --> 03:05.060
de las últimas 100 transiciones.

03:05.520 --> 03:08.440
De acuerdo, comencemos presentando la clase.

03:08.520 --> 03:17.460
Entonces, como saben, comenzamos con la clase y luego se los damos a la clase que llamamos memoria de

03:17.460 --> 03:25.500
repetición y luego, entre paréntesis, ingresamos el objeto, luego Cullin y luego comenzamos con la primera función.

03:25.560 --> 03:26.860
El final es función.

03:27.150 --> 03:30.730
Así que eso es exactamente lo mismo que antes de comenzar con la muerte.

03:30.870 --> 03:36.750
Luego, dos guiones bajos en él subrayan dos y luego las variables.

03:36.750 --> 03:42.750
las instancias futuras de la clase de objetos futuros y luego vamos a tener otra variable para que

03:42.750 --> 03:48.810
puedas probar alguna otra experiencia con algunos de los recuerdos y eso va a ser ser la capacidad.

03:48.810 --> 03:52.950
Entonces, por supuesto, existe el yo que es la variable asociada a

03:52.950 --> 03:58.020
Entonces esta capacidad será simplemente la número uno porque vamos a hacer que

03:58.020 --> 04:00.960
la experiencia juegue con las cien transiciones menos.

04:00.960 --> 04:03.910
De acuerdo y luego Collon Y aquí vamos.

04:03.930 --> 04:10.430
Vamos dentro de la función y definamos las variables de nuestro objeto de memoria de repetición.

04:10.440 --> 04:19.400
Por lo tanto, el primero será la capacidad autodidacta y, como probablemente haya entendido, esta será la capacidad que es el número

04:19.670 --> 04:24.690
máximo de transiciones que queremos tener en nuestra memoria de los eventos.

04:24.830 --> 04:30.980
crear un objeto de la clase de memoria de repetición y, por lo tanto, esa es la capacidad.

04:31.000 --> 04:34.530
Y esto será igual a los argumentos que ingresará al

04:34.550 --> 04:36.480
Ese es el argumento de la función init.

04:36.660 --> 04:38.180
Entonces la capacidad.

04:38.180 --> 04:44.960
Así que de nuevo no debe confundirse que esa capacidad es el nombre de la variable que se adjunta al

04:45.470 --> 04:52.670
objeto y la capacidad aquí es el argumento que ingresará al crear un objeto de la clase de memoria de repetición.

04:52.810 --> 04:53.620
Todo bien.

04:53.830 --> 04:55.880
Y luego tenemos un segundo voivoda.

04:56.170 --> 04:57.890
Eso es, por supuesto, el recuerdo.

04:58.000 --> 05:01.620
Así que autodidacta Nemec.

05:01.760 --> 05:02.650
Todo bien.

05:02.800 --> 05:05.730
Y entonces, ¿qué será este recuerdo Voivode?

05:05.990 --> 05:13.950
Bueno, se supone que este recuerdo contiene los últimos 100 eventos y, por lo tanto, debería ser una prueba simple.

05:14.100 --> 05:20.300
Usted conoce una lista que contendrá los últimos 100 eventos las últimas 100 transiciones y para inicializar

05:20.300 --> 05:20.850
la lista.

05:20.870 --> 05:24.620
No hay nada más simple, solo agregamos algunos paréntesis como ese.

05:24.740 --> 05:26.040
Y aquí vamos.

05:26.060 --> 05:31.490
Nuestra memoria se inicializa así que, por supuesto, al comienzo del experimento o más precisamente al

05:31.490 --> 05:36.430
comienzo de la exploración, la memoria será una lista vacía y luego pondremos las transiciones.

05:36.500 --> 05:38.350
Cada vez que alcanzamos un estado futuro.

05:38.600 --> 05:43.370
Y hablando de eso, eso es exactamente lo que haremos con la siguiente función a la que

05:43.520 --> 05:44.720
llamaremos función de inserción.

05:44.790 --> 05:51.380
Haremos esta función de inserción para plantar los eventos en esta lista de memoria y luego usaremos la

05:51.620 --> 05:57.170
capacidad para asegurarnos de que esta lista de memoria siempre contenga 100 eventos y nunca más.

05:57.500 --> 05:59.660
Muy bien, así que hagámoslo en la próxima también.

05:59.690 --> 06:01.250
Y hasta entonces yo