Hola y bienvenidos a la especia Intertoto.
Está bien, entonces en esta nueva sección de código vamos a implementar experiencia con el juego.
Así que vamos a hacer una nueva clase que llamaremos memoria de repetición y que implementará la experiencia para
jugar exactamente como viste en las conferencias de intuición.
Pero primero démonos un recordatorio rápido sobre lo que es la repetición de experiencia.
Así que sabes que toda esta inteligencia artificial se basa en los procesos de decisión de Markov y los
procesos de decisión de Markov consisten en observar una serie de eventos.
Así que los eventos son, por ejemplo, que van de un estado al siguiente y tipis uno.
Pero si los eventos fueron así desde el día siguiente, están muy correlacionados con el estado actual.
Bueno, a la red no le estaría yendo muy bien.
Entonces para aquellos que vienen del curso de aprendizaje profundo eso es exactamente lo mismo que aprendimos nuestra serie de
tiempo con solo un paso de tiempo.
No aprendía nada porque un paso de tiempo no era suficiente para que un modelo
aprendiera a entender las correlaciones a largo plazo.
Así que es lo mismo aquí y es por eso que tenemos que implementar la repetición de la experiencia.
Entonces, cómo funciona.
Bueno, eso es muy simple en lugar de considerar solo el estado actual que es solo un estado en el
tiempo t.
Vamos a considerar más en el pasado.
Así que exactamente como para los litios y por lo tanto nuestra serie de eventos no será tan.
Y supongo que uno será, por ejemplo, los cien estados en el pasado.
Entonces, como T-menos ciento ochenta menos 99 hasta menos-1 y luego S-T.
que llamamos la memoria y es por eso que tenemos una memoria a largo plazo en lugar de una memoria a
corto plazo o incluso debería decir una memoria instantánea y eso hace que todo el proceso funcione mucho mejor.
En otras palabras, ponemos 100 transiciones menos en lo
Y luego, una vez que creamos esta memoria de los últimos 100 eventos, simplificaremos que tome algunos
lotes aleatorios de estas transiciones para hacer nuestra próxima actualización.
Ese es nuestro próximo paso al seleccionar la siguiente sección y, por lo tanto, en esta clase de memoria de
repetición que estamos implementando para la reproducción de experiencia haremos tres funciones.
En primer lugar, la función habitual es el caso para cualquier clase.
Y así en esta función definiremos las variables que se adjuntarán a las instancias futuras de la clase que
son los objetos futuros que se crearán a partir de esta clase.
Y de manera muy simple, estas variables serán la memoria de las 100 transiciones a 100 eventos.
Y la capacidad que es el número 100 le invitará a probar una memoria más larga al aumentar
la capacidad.
Así que esa es la primera función en su función y luego realizaremos otras dos funciones, una función de
inserción para asegurarnos de que la memoria nunca contenga más de 100 transiciones.
Y para esto usaremos la capacidad simplemente haciendo una condición simple y luego eventualmente haremos
la función simple y eso será por supuesto para probar algunas transiciones en esta memoria
de las últimas 100 transiciones.
De acuerdo, comencemos presentando la clase.
Entonces, como saben, comenzamos con la clase y luego se los damos a la clase que llamamos memoria de
repetición y luego, entre paréntesis, ingresamos el objeto, luego Cullin y luego comenzamos con la primera función.
El final es función.
Así que eso es exactamente lo mismo que antes de comenzar con la muerte.
Luego, dos guiones bajos en él subrayan dos y luego las variables.
las instancias futuras de la clase de objetos futuros y luego vamos a tener otra variable para que
puedas probar alguna otra experiencia con algunos de los recuerdos y eso va a ser ser la capacidad.
Entonces, por supuesto, existe el yo que es la variable asociada a
Entonces esta capacidad será simplemente la número uno porque vamos a hacer que
la experiencia juegue con las cien transiciones menos.
De acuerdo y luego Collon Y aquí vamos.
Vamos dentro de la función y definamos las variables de nuestro objeto de memoria de repetición.
Por lo tanto, el primero será la capacidad autodidacta y, como probablemente haya entendido, esta será la capacidad que es el número
máximo de transiciones que queremos tener en nuestra memoria de los eventos.
crear un objeto de la clase de memoria de repetición y, por lo tanto, esa es la capacidad.
Y esto será igual a los argumentos que ingresará al
Ese es el argumento de la función init.
Entonces la capacidad.
Así que de nuevo no debe confundirse que esa capacidad es el nombre de la variable que se adjunta al
objeto y la capacidad aquí es el argumento que ingresará al crear un objeto de la clase de memoria de repetición.
Todo bien.
Y luego tenemos un segundo voivoda.
Eso es, por supuesto, el recuerdo.
Así que autodidacta Nemec.
Todo bien.
Y entonces, ¿qué será este recuerdo Voivode?
Bueno, se supone que este recuerdo contiene los últimos 100 eventos y, por lo tanto, debería ser una prueba simple.
Usted conoce una lista que contendrá los últimos 100 eventos las últimas 100 transiciones y para inicializar
la lista.
No hay nada más simple, solo agregamos algunos paréntesis como ese.
Y aquí vamos.
Nuestra memoria se inicializa así que, por supuesto, al comienzo del experimento o más precisamente al
comienzo de la exploración, la memoria será una lista vacía y luego pondremos las transiciones.
Cada vez que alcanzamos un estado futuro.
Y hablando de eso, eso es exactamente lo que haremos con la siguiente función a la que
llamaremos función de inserción.
Haremos esta función de inserción para plantar los eventos en esta lista de memoria y luego usaremos la
capacidad para asegurarnos de que esta lista de memoria siempre contenga 100 eventos y nunca más.
Muy bien, así que hagámoslo en la próxima también.
Y hasta entonces yo