WEBVTT

00:00.450 --> 00:02.670
Hola y bienvenidos a este patrón, es horror.

00:02.850 --> 00:06.890
Muy bien, así que solo actualizamos la memoria después de alcanzar el nuevo estado.

00:06.900 --> 00:09.010
Y ahora cuidémonos del día siguiente.

00:09.330 --> 00:12.810
Según usted, ahora cuál será la próxima actualización.

00:12.810 --> 00:20.040
Bueno, básicamente, hemos terminado con una transición que hemos fechado el último elemento de la transición, que es el

00:20.040 --> 00:20.960
nuevo estado.

00:21.150 --> 00:23.340
Así que ahora es como si comenzáramos de nuevo.

00:23.520 --> 00:25.530
Y cuando estábamos empezando todo de nuevo.

00:25.650 --> 00:31.320
Es como si supieras que estamos en este nuevo estado del medio ambiente y, entonces, ¿qué tenemos que hacer ahora de forma natural?

00:31.500 --> 00:37.170
Bueno, por supuesto, es para actuar porque ya tenemos la observación de las noticias.

00:37.410 --> 00:43.290
Ahora lo que tenemos que hacer es jugar una acción y, por lo tanto, lo que tenemos que hacer ahora es,

00:43.290 --> 00:46.960
por supuesto, utilizar la función de acción de selección para ejecutar la acción.

00:47.010 --> 00:54.320
Así que hagámoslo, creemos una nueva acción Voivode y juguemos la acción con la acción seleccionada, así que

00:54.320 --> 00:55.240
estoy tomando.

00:55.380 --> 01:03.150
Primero, es bueno especificar que la función de acción de selección es un método del objeto de la clase

01:03.150 --> 01:04.300
que se creará.

01:04.470 --> 01:08.610
Entonces un yo que selecciona acción.

01:08.640 --> 01:09.520
Aquí vamos.

01:09.560 --> 01:11.090
Entonces esa es la próxima acción.

01:11.310 --> 01:17.560
Y luego, por supuesto, dado que la función de acción de selección toma el estado como entrada porque, por supuesto,

01:17.560 --> 01:24.270
la función de acción de selección devolverá la salida de la red neuronal cuando el estado de entrada actual ingrese a

01:24.270 --> 01:25.220
la red neuronal.

01:25.500 --> 01:31.650
y dado que son los estados que acabamos de alcanzar en el entorno en este momento donde el estado de

01:31.650 --> 01:37.350
entrada es, por supuesto, su estado, porque este estado al que recién llegamos en este momento es Newstead.

01:37.350 --> 01:40.070
Entonces, tenemos que ingresar la etapa de entrada aquí

01:40.290 --> 01:45.140
Entonces, en esta función de acción selectiva me refiero a poner nuevos palos.

01:45.150 --> 01:51.710
De acuerdo, con esta línea de código simplemente jugamos la nueva acción después de alcanzar el nuevo estado.

01:52.140 --> 01:58.780
OK y ahora que jugamos una acción Bueno, obtenemos la recompensa y, por lo tanto, recibimos retroalimentación con la recompensa.

01:59.010 --> 02:04.550
Y, por lo tanto, si tenemos más de 100 elementos en la memoria, sería tiempo de aprender.

02:04.860 --> 02:10.830
Y, por lo tanto, lo que debemos hacer ahora es lo que lógicamente viene después de seleccionar una acción que, por

02:10.830 --> 02:13.830
supuesto, disminuya la necesidad de AI de comenzar a aprender.

02:13.950 --> 02:15.620
Si está haciendo las cosas de la manera correcta.

02:15.870 --> 02:22.530
Y ahora, dado que jugó bien la acción, haremos que la IA aprenda de sus acciones en

02:22.530 --> 02:23.940
los últimos 100 eventos.

02:24.130 --> 02:31.320
Pero antes de aplicar esta función aprendida tenemos que hacer esta condición para asegurarnos de que ya hemos alcanzado

02:31.320 --> 02:37.380
más de 100 eventos porque sabes que estamos aprendiendo de las muestras aleatorias de la memoria.

02:37.530 --> 02:41.110
Sabes que tenemos esta gran memoria de 10000 elementos.

02:41.190 --> 02:48.930
Estamos tomando algunas muestras aleatorias de la memoria de 100 elementos y la IA está aprendiendo de la

02:48.990 --> 02:52.850
información contenida en esta muestra de 100 transiciones aleatorias.

02:52.860 --> 03:00.690
el objeto de su clase de memoria de repetición, pero luego la clase de memoria de repetición tiene una atributo que es memoria.

03:00.810 --> 03:06.390
Así que hagamos esta condición si queremos asegurarnos de que el número de elementos de la

03:06.390 --> 03:12.380
memoria de esa memoria y luego tenga cuidado solo con un pequeño truco. Aquí la memoria autodidacta es

03:12.510 --> 03:21.780
Entonces, de hecho, necesitamos tomar parte de la memoria de la memoria: la primera memoria es el objeto de la clase de

03:21.780 --> 03:28.170
memoria de repetición y la segunda memoria es el atributo aquí mismo de esa memoria.

03:28.200 --> 03:37.350
Entonces, si la cantidad de elementos en la memoria es buena, queremos que sea mayor que 100, luego Cullin Y luego,

03:37.860 --> 03:38.800
qué sucede.

03:38.970 --> 03:46.320
Bueno, podemos aprender, pero para aprender necesitamos obtener esta muestra aleatoria de 100 transiciones y esto lo

03:46.320 --> 03:48.840
podemos lograr con la simple función.

03:48.840 --> 03:55.140
Y dado que la función simple devuelve los diferentes lotes a los estados en el tiempo t estos datos 20 más uno

03:55.290 --> 03:57.950
las acciones del tiempo t y estábamos en 20.

03:58.200 --> 04:03.360
Bueno, lo que tenemos que hacer ahora es crear algunos nuevos avivamientos que serán el lote

04:03.360 --> 04:08.580
de los estados en el tiempo t el lote de las próximas fechas el lote de

04:08.580 --> 04:16.030
las palabras y el lote de las acciones y podemos simplemente dar los mismos nombres como dijimos para los argumentos aquí y están aquí.

04:16.200 --> 04:24.720
Y estas variables serán iguales a lo que devuelve la función simple, ya que devuelve exactamente estos lotes

04:24.720 --> 04:28.320
y el estado siguiente toma palabras y acciones.

04:28.320 --> 04:35.570
memoria y luego de este objeto de memoria vamos a usar el método simple que tomará como entradas.

04:35.620 --> 04:40.300
Entonces, lo que necesitamos hacer ahora es obtener primero nuestro objeto de

04:40.500 --> 04:46.370
Bueno, la cantidad de transiciones de las que queremos que nuestra IA aprenda es de 100.

04:46.620 --> 04:50.540
Es por eso que nos aseguramos de que tuviéramos más de cien transiciones.

04:50.610 --> 04:54.780
Entonces aprenderá de 100 transiciones de la memoria.

04:54.840 --> 04:56.500
Entonces el aprendizaje será mucho mejor.

04:56.610 --> 04:59.560
Y entonces, hagamos que esto realmente suceda.

04:59.700 --> 05:04.560
Bueno, ya que el método de aprendizaje es un método de nuestra clase.

05:04.830 --> 05:11.180
los objetos futuros que se crearán a partir de una clase diferente y, por lo tanto, lo que debemos tomar es uno mismo.

05:11.190 --> 05:14.300
Bueno, necesitamos acceder a este método de aprendizaje a partir de

05:14.430 --> 05:21.960
Uno mismo se refiere a ese objetivo de hacer durante la clase y luego aprender como este método aprendido Método aprendido a

05:22.470 --> 05:29.340
la cual, cuando se pone Por supuesto, estos tipos aquí el mal estado del estado belga el mundo natural y

05:29.340 --> 05:30.530
la acción Bachche.

05:30.630 --> 05:38.730
Estos son nuestros lotes tomados de nuestra memoria y obtenemos 100 de ellos porque tenemos 100

05:39.330 --> 05:47.750
transiciones de estas 100 transiciones. Tomamos 100 estados 100 luego estados 100 recompensas y 100 acciones Afrontemos

05:47.780 --> 05:51.530
aquí y allá vamos Ahora el aprendizaje sucederá.

05:51.850 --> 05:54.490
Pasará de todos estos lotes aleatorios.

05:54.520 --> 05:55.850
Perfecto.

05:55.960 --> 06:03.310
Y ahora lo que tenemos que hacer son las últimas actualizaciones después de saber que alcanzas un nuevo estado y juegas

06:03.310 --> 06:04.140
en acción.

06:04.330 --> 06:08.890
Bueno, tenemos que jugar, pero todavía no tuvimos esa reacción.

06:08.920 --> 06:11.590
Ese es nuestro ser el último voivoda de acción.

06:11.770 --> 06:13.730
Así que asegurémonos de que no olvidemos esto.

06:13.780 --> 06:15.160
Hagámoslo ahora.

06:15.190 --> 06:24.610
que iguale a la última acción y por supuesto acción la acción que nos quedamos aquí con esta función de acción seleccionada.

06:24.610 --> 06:27.020
Actualizaremos el último yo de acción

06:27.020 --> 06:30.520
Ahora mismo, la última sección se actualiza entonces.

06:30.520 --> 06:31.890
Lo mismo para el nuevo estado.

06:31.930 --> 06:39.190
Alcanzamos el nuevo estado, pero no hemos actualizado la última fecha porque, por supuesto, el último estaba antes del estado

06:39.280 --> 06:40.590
en el momento t.

06:40.750 --> 06:44.870
Pero desde ahora llegamos al nuevo superávit estatal cuando es hora de aprobar uno.

06:45.070 --> 06:48.180
Bueno, el último se convierte en esto que dijiste aquí.

06:48.190 --> 06:50.290
Por lo tanto, necesitamos actualizar también.

06:50.290 --> 06:57.070
Self ese último estado es igual a nuestro nuevo estado.

06:57.280 --> 06:58.020
Aquí vamos.

06:58.210 --> 06:59.620
Y ahora, ¿qué necesitamos para salir?

06:59.830 --> 07:01.640
Bueno, solo queda una cosa.

07:01.660 --> 07:08.070
Por supuesto, la palabra y la palabra son exactamente las que recibimos en realidad.

07:08.290 --> 07:15.910
Entonces ese será el argumento de esta función que si hiciéramos la conexión a nuestro mapa será

07:15.910 --> 07:17.160
la última palabra.

07:17.200 --> 07:23.250
Esa es la palabra que recibimos justo después de jugar la acción en este nuevo estado alcanzado.

07:23.470 --> 07:30.260
Entonces, si continuamos con algún sonido, esta última palabra será menos uno, si nos alejamos de la marcha

07:30.290 --> 07:35.580
obtendremos una palabra ligeramente mala menos 0. 2 si nos acercamos a la meta.

07:35.660 --> 07:38.680
Obtendremos una recompensa ligeramente buena 0. 1.

07:38.830 --> 07:43.370
Y si nos acercamos demasiado a un borde del mapa, eso será un castigo.

07:43.510 --> 07:45.330
Obtendremos menos uno por cada uno.

07:45.440 --> 07:47.110
Así que esa es la última palabra que recibimos.

07:47.110 --> 07:50.700
En realidad, eso es cuando eso sucede de verdad en el mapa.

07:50.830 --> 07:53.550
Y este será el argumento de la función.

07:53.600 --> 07:54.690
La última palabra aquí.

07:54.700 --> 07:56.200
Esa es exactamente esta.

07:56.250 --> 08:01.840
Y como este es el argumento de la función de actualización que corresponde

08:02.170 --> 08:11.590
a esto, no estábamos aquí y, por lo tanto, nuestro yo, la última variable de palabra inicializada al principio en esta

08:12.070 --> 08:20.570
función se convierte en la nueva palabra que en realidad es la palabra o eso la misma última palabra

08:20.730 --> 08:21.360
Todo bien.

08:21.410 --> 08:23.680
Ahora actualizamos nuestra última palabra.

08:23.990 --> 08:27.240
Y ahora, ya que tenemos nuestra última palabra.

08:27.500 --> 08:29.470
Bueno, ahora podemos salir con el mundo.

08:29.850 --> 08:37.140
Recuerdas la guerra cuando se inicializaron aquí como una de las variables del objeto de nuestra clase.

08:37.190 --> 08:42.500
Esa es la ventana que hará un seguimiento de cómo va este tren, tomando el promedio

08:42.500 --> 08:44.270
de las últimas 100 recompensas.

08:44.300 --> 08:50.180
Entonces sabes que será como una ventana deslizante que nos muestra cómo evoluciona la media del mundo.

08:50.180 --> 08:52.730
Y así que ya tenemos nuestra última palabra.

08:52.910 --> 08:56.910
Bueno, podemos actualizar la ventana de cómo estábamos actualizados.

08:57.080 --> 09:03.680
mi ventana de guerra como palabra cuando escuchemos esto y voy a usar la función de agregar.

09:03.980 --> 09:12.350
Bueno, simplemente tenemos que añadir esta última palabra a la ventana y, por lo tanto, lo que voy a hacer es tomar

09:12.530 --> 09:18.830
Y dentro de la función abierta necesitamos ingresar el elemento que queremos agregar al que

09:18.830 --> 09:21.480
estábamos cuando hacemos eso, por supuesto, queremos.

09:21.500 --> 09:22.610
Muy bien, perfecto.

09:22.610 --> 09:29.480
Y como esta ventana de guerra tendrá un tamaño fijo, sabrá que no va a ser una ventana en crecimiento, será

09:29.480 --> 09:35.300
una ventana de tamaño fijo que se desliza con el tiempo para mostrar la evolución del mundo.

09:35.500 --> 09:38.590
Y ahora tenemos que decidir por un tamaño de este invierno.

09:38.750 --> 09:43.600
Y es simplemente la cantidad de medios de la recompensa que tendremos en esta ventana.

09:43.900 --> 09:49.330
Y así, por ejemplo, vamos a conocer los últimos 1000 medios de las últimas 100 palabras.

09:49.340 --> 09:58.730
Y para asegurarnos de que vamos a agregar si planificamos entonces tomamos nuestra ventana de trabajo y simplemente

09:58.740 --> 10:05.810
agregamos aquí si la cantidad de elementos en la ventana es mayor a 1000.

10:05.990 --> 10:14.780
Bueno, lo que queremos hacer es eliminar el primer elemento de este que nuestra ventana y el

10:14.780 --> 10:19.070
primer elemento de esta ventana tiene que indexar cero.

10:19.150 --> 10:19.550
Todo bien.

10:19.550 --> 10:24.620
Ahora nos aseguramos de que esta ventana de guerra nunca obtenga más de 1000 elementos.

10:24.620 --> 10:31.130
perfectos, esto será una ventana de tamaño fijo para que podamos ver si la media de la palabra está aumentando.

10:31.310 --> 10:34.360
Hay mil medios de las últimas 100 palabras que son

10:34.460 --> 10:39.560
Y, por lo tanto, si la capacitación va bien y, en consecuencia, la corte hace lo que queremos.

10:39.800 --> 10:40.760
Perfecto.

10:41.000 --> 10:46.010
Y ahora, una pequeñita cosa que hacer te deja a ti como va a ser.

10:46.190 --> 10:52.130
Recuerda que esta función de actualización no solo actualiza los diferentes elementos de la transición en la

10:52.140 --> 10:57.960
ventana de guerra, sino que también devuelve la acción que se jugó al alcanzar este nuevo estado.

10:58.190 --> 11:05.270
Es por eso que tenemos y luego esa acción es igual a traer esa fecha en la que somos menos señal y, por lo tanto,

11:05.360 --> 11:10.760
se supone que debe devolver algo, y lo que se supone que debe regresar es, por supuesto, la acción.

11:10.820 --> 11:18.950
Entonces, lo último que necesitamos hacer aquí es solo la acción de retorno, la acción que se acaba de jugar cuando alcanzamos

11:18.950 --> 11:20.180
la nueva etapa.

11:20.600 --> 11:23.670
Y esa es nuestra función de actualización está lista.

11:23.840 --> 11:29.110
Va a hacer todas las actualizaciones necesarias y hará que la acción llegue a la nueva etapa.

11:29.480 --> 11:30.650
Eso es perfecto.

11:30.650 --> 11:35.230
Esa fue la última acción difícil de hacer para todo esto, un proceso.

11:35.240 --> 11:37.120
Ahora el resto será bueno.

11:37.220 --> 11:42.170
Simplemente haremos una función central para devolver los medios que queremos en la ventana.

11:42.200 --> 11:47.450
Luego haremos una función segura para salvar el cerebro del automóvil cada vez que desee salir de la aplicación

11:47.600 --> 11:48.840
y volver a ella.

11:48.890 --> 11:53.720
Y, por supuesto, dado que desea cargar el cerebro de su automóvil cuando regrese, regrese

11:53.720 --> 11:54.730
a la aplicación.

11:55.040 --> 12:01.370
Bueno, terminaremos haciendo una función de carga que cargará su modelo después de guardar su modelo

12:01.370 --> 12:02.800
con la misma función.

12:02.840 --> 12:06.470
Así que tres funciones para hacer eso, pero va a ser simple.

12:06.500 --> 12:12.760
la sección más emocionante de este primer módulo que es la demostración que veremos si el aire funciona.

12:12.770 --> 12:13.840
Y luego tendremos

12:13.850 --> 12:19.430
Veremos si el coche alcanza los objetivos y veremos cómo podemos mejorarlo y, finalmente,

12:19.430 --> 12:21.980
tendrá que construir su primera IA.

12:22.160 --> 12:24.010
Así que no puedo esperar para comenzar la demostración.

12:24.140 --> 12:27.580
Hagamos estas tres funciones primero y hasta entonces I.