WEBVTT

00:00.300 --> 00:02.000
Hola y bienvenido a este tutorial.

00:02.160 --> 00:05.090
Felicidades de nuevo por haber terminado con esto.

00:05.150 --> 00:08.200
Mira, lo hicimos, hicimos los cerebros y los entrenamos.

00:08.400 --> 00:15.600
Pero ahora todavía tenemos que hacer un agente de prueba que mañana no tendrá una fecha para nada, pero solo

00:15.780 --> 00:19.430
usará el modelo de compartir para hacer sus propias exploraciones.

00:19.530 --> 00:26.080
Y, por supuesto, en este código vamos a grabar algunos videos y estos serán los videos de los

00:26.090 --> 00:28.750
agentes de prueba con un puntaje determinado.

00:28.810 --> 00:30.840
Entonces, revisemos este código.

00:30.850 --> 00:35.860
Lo más importante está hecho así que te dije que no vamos a codificarlo línea por línea, pero creo

00:35.860 --> 00:38.580
que es importante que entiendas lo que está sucediendo aquí.

00:38.800 --> 00:42.680
Entonces, vamos a ir con este código en la primera sección, como habrás notado.

00:42.790 --> 00:49.480
Importamos las bibliotecas y luego encontramos esta función de prueba que hará que este agente de prueba haga su

00:49.480 --> 00:52.390
propia exploración y juegue el juego de lanzamiento.

00:52.600 --> 00:58.610
Entonces, obtenemos que esta función de prueba toma tres argumentos; el primero es la clasificación que aún debe sincronizar el

00:58.850 --> 01:02.060
agente de prueba, como hicimos con los agentes de capacitación.

01:02.230 --> 01:05.380
Entonces tenemos nuestros parámetros, por supuesto, porque necesitas algunos.

01:05.380 --> 01:12.220
Y, por supuesto, tenemos el modelo compartido porque este agente de prueba usará un modelo compartido para hacer

01:12.220 --> 01:13.360
su propia exploración.

01:13.360 --> 01:18.790
Bien, entramos en la función y esta línea de código sincronizamos con el agente de prueba.

01:18.820 --> 01:23.120
Exactamente como lo hicimos antes, importamos el entorno.

01:23.170 --> 01:27.070
Así que lo recuerdo en el código principal que estará en el próximo tutorial.

01:27.250 --> 01:33.970
Bueno, y el nombre aquí será reemplazado por una ruptura de cero para que podamos entrar en el entorno de descanso

01:34.060 --> 01:40.180
cero y jugar el juego y los Trumans de la Cruz Roja que obtendrán los videos de nuestro evento nocturno.

01:40.180 --> 01:46.680
Entonces, básicamente, esta línea de código en total significa que ejecutamos un entorno con video.

01:47.080 --> 01:54.520
Luego, en la siguiente línea de código, sincronizamos este entorno con el mismo principio exacto que la función Trend.

01:54.700 --> 02:02.170
Luego obtenemos nuestro modelo y para ello creamos un objeto de la clase de actividad y ponemos la forma de entrada

02:02.170 --> 02:08.920
con nuestro espacio de observación del entorno y los ceros con forma son exactamente como la función del tren

02:09.190 --> 02:13.690
y nuestros productos que son las acciones con un espacio de acción.

02:13.900 --> 02:19.770
Así que exactamente como antes, entonces algo nuevo aquí ya que hemos terminado con el entrenamiento.

02:19.870 --> 02:25.450
No queremos poner el modelo en modo de tren porque simplemente no queremos que se entrene,

02:25.450 --> 02:26.880
queremos ponerlo en desarrollo.

02:27.160 --> 02:29.740
Y eso es lo que hacemos aquí con un modelo que evolucionó.

02:29.890 --> 02:36.940
Así que eso es básicamente para poner al agente de prueba en un modo que básicamente probará

02:37.030 --> 02:38.350
el desempeño evaluado.

02:38.720 --> 02:45.680
Luego, aquí tenemos nuestros estados de entrada que son las imágenes de entrada del juego que en este punto son

02:45.680 --> 02:46.790
una raza completa.

02:46.840 --> 02:49.360
Luego los convertimos en bailarines de antorchas.

02:49.480 --> 02:52.810
Aquí inicializamos algunas de las palabras aquí.

02:52.840 --> 02:54.980
Inicializamos a verdadero.

02:55.200 --> 03:03.430
última vez, y luego algo nuevo, introducimos esta tercera viabilidad con una función de tiempo para medir el tiempo de los cálculos.

03:03.850 --> 03:05.990
Así que, al igual que la

03:06.190 --> 03:08.680
Y eso es porque quieres obtener el punto de partida.

03:08.890 --> 03:15.160
Luego, aquí las acciones usamos un tipo de pista muy práctica que permite agregar un elemento a la señal desde la

03:15.160 --> 03:16.550
derecha o desde la izquierda.

03:16.600 --> 03:21.960
Así que eso es muy práctico y te daré la referencia, creo, en una versión decrementada del código.

03:22.180 --> 03:27.320
Entonces, echarán un vistazo a lo que es esta dequeue y eso es lo que permite hacer eso.

03:27.490 --> 03:33.370
Luego, inicializamos la duración de un episodio con cero, por supuesto, y luego aumentaremos el tamaño en

03:33.400 --> 03:34.690
este ciclo de pozo.

03:34.870 --> 03:36.480
Entonces usamos el mismo truco aquí.

03:36.680 --> 03:42.290
Si bien es cierto y en el ciclo incrementamos la duración del episodio en uno.

03:42.490 --> 03:49.700
Cuando el juego finaliza cuando termina el juego, volvemos a cargar el último conjunto del modelo compartido, el modelo compartido que

03:49.730 --> 03:51.460
data de los otros modelos.

03:51.460 --> 03:55.610
Recuerde que aquí el modelo compartido ya no está fechado.

03:55.660 --> 04:04.030
Sin embargo, si el juego termina, si el juego está terminado Reinette reiniciamos los estados de celda, vemos

04:04.190 --> 04:13.840
X y luego establece H x, y si el juego no termina bien, mantenemos los mismos estados de celda y estado.

04:13.840 --> 04:18.030
Pero para asegurarse de que se les enseñe variables de modo que puedan unirse a un degradado.

04:18.170 --> 04:25.240
OK, entonces eso es algo que ya hemos muerto en la función de tendencia y luego todavía en el ciclo while y después

04:25.240 --> 04:30.870
de tener un dato que indica en los estados ocultos el camino correcto, dependiendo de los dos casos aquí.

04:31.060 --> 04:34.360
Bien, ¿qué hacemos? Tenemos las predicciones del mañana.

04:34.450 --> 04:37.380
Eso es exactamente lo que hacemos aquí con esta línea de código.

04:37.750 --> 04:43.360
Entonces obtenemos el valor que es el resultado del crítico, el valor real que es el resultado del actor.

04:43.600 --> 04:49.750
Y luego están todos los estados ocultos H x y la celda declara la X, luego generamos una distribución de probabilidades

04:49.750 --> 04:54.130
de las acciones que está en el valor de acción de los valores Q aquí.

04:54.270 --> 04:56.380
Y hacemos esto con la siguiente función.

04:56.470 --> 05:01.230
Y, por supuesto, no necesitamos obtener las probabilidades de suerte aquí porque esto es solo para el entrenamiento

05:01.480 --> 05:02.650
del agente de prueba.

05:02.650 --> 05:09.130
Simplemente reproducirá las acciones que usaremos, ya sabes, como una actividad determinada para jugar, pero

05:09.190 --> 05:10.920
no estamos entrenando aquí.

05:10.960 --> 05:19.040
Entonces tenemos solo un prop y de esto jugamos la acción llevando directamente a RMX de estas probabilidades, es decir,

05:19.040 --> 05:22.720
toma la acción que tiene la probabilidad más alta.

05:22.810 --> 05:26.860
Y la razón es que el agente de prueba no realiza ninguna exploración.

05:26.860 --> 05:32.830
probabilidad nuevamente, luego, una vez que jugamos la acción, alcanzamos el siguiente estado y obtenemos la siguiente palabra.

05:32.830 --> 05:38.170
Recuerde que queremos tener la oportunidad de retomar algunas acciones que tienen bajas probabilidades cuando desee explorar

05:38.170 --> 05:44.260
un poco estas otras acciones y usted sabe que no tomará cada vez la acción que tenga la probabilidad

05:44.260 --> 05:50.800
más alta, pero aquí el agente de prueba puede hacer cualquier exploración y por lo tanto, es por eso que

05:50.800 --> 05:53.340
tomamos directamente la acción que tiene la máxima

05:53.470 --> 05:56.920
Y ese es un día fechado ya sea que el juego haya terminado o no.

05:57.160 --> 06:03.700
Entonces, obtenemos todo esto con esta línea de código ejecutando la acción después de haberla seleccionado con nuestro

06:03.790 --> 06:04.630
Max aquí.

06:04.840 --> 06:13.000
lo hacemos nuevamente y luego, dado que recibimos una nueva recompensa, vamos a actualizar parte de la recompensa simplemente agregando esta nueva palabra.

06:13.090 --> 06:18.950
Entonces jugamos la acción aquí y obtenemos el estado en el que obtenemos la recompensa y

06:19.180 --> 06:21.480
Y finalmente cada vez que el juego está hecho.

06:21.490 --> 06:28.510
Entonces, si eso significa que cuando termine el juego, cuando termine de jugar bien, vamos a imprimir

06:28.510 --> 06:31.210
los resultados con el tiempo opuesto.

06:31.230 --> 06:36.100
Queríamos que la duración del episodio fuera la cantidad de tiempo que duró.

06:36.100 --> 06:42.890
Jugar muy bien y así es como imprimimos todas estas variables usando estos pequeños trucos.

06:42.910 --> 06:46.280
Eso es por el momento, entonces queremos algo; es solo una variable.

06:46.340 --> 06:51.960
Algunas de las palabras e ideas son extensas a la duración del presente OK.

06:52.160 --> 06:57.860
Y luego, una vez que imprimimos bien todos los resultados, ya que el juego terminó y queremos comenzar un

06:58.220 --> 06:59.930
nuevo juego, vamos a reinicializar todo.

06:59.930 --> 07:04.170
Esa es la suma de dos palabras, cero la duración de un episodio a cero.

07:04.230 --> 07:10.100
Vamos a volver a representar todas las acciones mediante el uso de esta función clave que restablece las imágenes

07:10.100 --> 07:13.360
de entrada que conoce repitiendo todos los descansos por completo.

07:13.610 --> 07:21.980
Y finalmente usamos este tiempo que duerme 60 segundos para hacer un descanso de un minuto para permitir que otros

07:21.980 --> 07:22.840
agentes practiquen.

07:22.850 --> 07:24.810
Y eso si el juego ha terminado.

07:25.210 --> 07:25.840
DE ACUERDO.

07:25.940 --> 07:32.210
Y finalmente tenemos esta última línea de código que nos dará el nuevo estado y luego podemos avanzar.

07:32.240 --> 07:34.550
Podemos continuar en este nuevo juego.

07:34.550 --> 07:35.840
Entonces ahí vamos

07:35.870 --> 07:37.430
Esa es la función de prueba.

07:37.430 --> 07:40.550
Cosas a las que verás los videos en uno o dos tutoriales.

07:40.550 --> 07:45.310
Espero que sea del todo como la última vez para ver los resultados que están con usted.

07:45.350 --> 07:47.360
Curial y yo, eso será divertido.

07:47.480 --> 07:48.400
Y te estoy diciendo.

07:48.440 --> 07:50.330
Espere ver buenos resultados.

07:50.360 --> 07:55.130
Pero ten en cuenta que este juego fue super desafiante.

07:55.130 --> 07:58.430
Pensamos que era un juego simple para jugar primero, pero no para nada.

07:58.430 --> 08:01.480
En realidad resultó ser mucho más difícil que la perdición.

08:01.670 --> 08:03.890
Y es por eso que lo ponemos en el último módulo.

08:04.190 --> 08:09.510
Pero de todos modos vamos a hacer esta función principal en el próximo tutorial.

08:09.590 --> 08:11.770
Lo mismo Esto no es lo más importante aquí.

08:11.780 --> 08:18.860
Ahora que el A-380 está demente, no lo codificaremos línea por línea, expandirá el código y muy

08:18.980 --> 08:20.570
rápidamente obtendremos los resultados.

08:20.570 --> 08:22.130
Hasta entonces, disfruta de la IA.
