WEBVTT

00:00.330 --> 00:05.940
Hola y bienvenidos a este tutorial, este juguete especial va a ser súper emocionante porque nos estamos acercando

00:05.940 --> 00:08.540
al A. S. DO. algoritmo.

00:08.700 --> 00:14.190
Vas a ver que lo que estamos a punto de implementar y que se llama seguimiento de elegibilidad

00:14.520 --> 00:20.250
o Sarsour es en realidad un algoritmo de los algoritmos de agentes de críticos activos sincrónicos que no podemos

00:20.250 --> 00:20.380
considerar.

00:20.380 --> 00:25.290
tener un agente, pero aún así verá que lo que estamos por implementar se

00:25.290 --> 00:32.010
toma en realidad del siguiente documento, que es este documento como el método Synchronoss para el aprendizaje de refuerzo

00:32.130 --> 00:38.280
profundo y es en este documento encontrará algoritmos A-3 que implementaremos como la bonificación final de este curso.

00:38.280 --> 00:40.840
Y lo vemos porque aún vamos a

00:41.010 --> 00:47.580
Pero como dije, nos estamos acercando porque el modelo que se implementará en este momento es este

00:48.420 --> 00:55.620
sincrónico y secularizado, que es casi el A3 C que está haciendo después de eso, pero con un

00:55.620 --> 01:03.490
agente y lo más poderoso de esto es esto y el paso Cunanan vamos a aprender a acumular recompensas y

01:03.490 --> 01:09.520
aprender el objetivo acumulativo en los pasos finales en lugar de un paso como Priestley.

01:09.690 --> 01:15.250
Y eso es lo que hará que el entrenamiento tenga mucho más rendimiento y, por lo tanto, será mucho más poderoso.

01:15.300 --> 01:21.080
Entonces realmente tenemos el pseudo código para este algoritmo, este es el algoritmo aquí.

01:21.180 --> 01:23.230
Hagamos clic en él y ahí vamos.

01:23.250 --> 01:25.740
Ese es el algoritmo que vamos a implementar.

01:25.890 --> 01:30.960
Pero recuerde que con un solo agente la diferencia es que aquí toman una acción.

01:30.990 --> 01:37.380
80 según el presidente Greely política basada en los valores q para el estado actual y la

01:37.380 --> 01:38.020
acción jugada.

01:38.190 --> 01:42.050
Pero en nuestro caso no implementamos una excelente política ecológica.

01:42.090 --> 01:43.770
Implementamos un Max.

01:43.890 --> 01:46.110
Pero el resto es lo mismo que puedes ver.

01:46.110 --> 01:50.210
Vamos a calcular el acumulado en el que trabajamos y los pasos en realidad 10 pasos.

01:50.220 --> 01:52.340
Recuerde que los pasos son iguales a 10.

01:52.440 --> 01:58.170
Y entonces implementaremos esta línea de código en nuestro algoritmo que estamos a punto de implementar en este momento.

01:58.170 --> 01:59.010
Vamos a obtener esto.

01:59.010 --> 02:02.150
Y sobre todo, vamos a implementar esto también.

02:02.160 --> 02:07.590
Verá que obtendremos el máximo de los valores q para el estado actual y la acción

02:07.590 --> 02:08.820
actual en este theta.

02:08.820 --> 02:11.150
Aquí hay solo un parámetro objetivo.

02:11.430 --> 02:15.350
Entonces, hagamos esto, ataquemos este algoritmo.

02:15.360 --> 02:18.730
Este se llama el aprendizaje sincrónico y stick.

02:18.900 --> 02:24.490
Pero no tenemos derecho a decir sincrónico en lo que a nosotros respecta porque solo tenemos un motor.

02:24.670 --> 02:29.830
Pero, por lo tanto, podemos llamarlo y aprender el rastro de elegibilidad o incluso Sarsour.

02:30.270 --> 02:31.780
Está bien, así que hagámoslo.

02:31.800 --> 02:33.080
Va a ser muy divertido.

02:33.090 --> 02:37.460
Básicamente, podemos seguir el código aquí y eso es lo que vamos a hacer.

02:37.460 --> 02:43.980
Y, como puede ver, un parámetro que necesitaremos es nuevamente el parámetro que es el parámetro

02:44.280 --> 02:50.820
de decaimiento y, por lo tanto, comenzaremos introduciendo una variable para este parámetro de Gahanna y seleccionándolos.

02:50.820 --> 02:51.840
Entonces, hagamos esto.

02:51.900 --> 02:57.040
En realidad, no necesitamos un aula tremenda Podemos simplemente implementar esto con una función porque sabes que

02:57.040 --> 03:01.830
realmente no necesitamos crear objetos para que esto sea para rastrear el modelo de una función

03:02.190 --> 03:08.500
será suficiente porque básicamente lo que queremos hacer es devuelve las entradas y el objetivo para que luego, al entrenar

03:08.500 --> 03:14.460
a la IA, estemos listos para minimizar la distancia entre las predicciones y el objetivo y para obtener las

03:14.470 --> 03:19.950
predicciones necesitamos las entradas porque vamos a aplicar nuestro cerebro en la entrada para obtener la salida señales

03:19.950 --> 03:21.300
que serán nuestras predicciones.

03:21.300 --> 03:26.730
para entrenar a la IA tratando de minimizar esta gran distancia entre las predicciones y los sanitarios.

03:26.730 --> 03:30.680
Y una vez que tengamos nuestras predicciones y nuestros objetivos, estaremos listos

03:30.690 --> 03:32.780
Entonces ese es el punto de hacer esto ahora mismo.

03:32.880 --> 03:38.130
Estamos implementando esta función para poder devolver estas entradas en los soviéticos, de modo que podamos estar

03:38.130 --> 03:43.010
listos para el entrenamiento a fin de minimizar las predicciones de distancias cuadradas para administrar inodoros.

03:43.020 --> 03:46.400
De acuerdo, hagamos esto, ya que dijimos que queremos implementar funciones.

03:46.410 --> 03:47.910
Comenzamos con esto.

03:47.940 --> 03:52.680
Esto lo llamaremos rastro subrayado de elegibilidad.

03:52.860 --> 03:54.210
También puedes llamarlo Sarsour.

03:54.240 --> 04:00.660
También puede llamarlo para sonar lo que quiera, pero vamos a llamarlo "rasgo de elegibilidad" y esta

04:00.660 --> 04:07.530
función va a tomar un argumento que va a ser un lote y por qué es porque vamos

04:07.530 --> 04:13.460
a obtener algunas entradas y algunos objetivos porque vamos a entrenar a la IA en lotes.

04:13.530 --> 04:19.170
Y entonces las entradas y los objetivos entrarán en algunos lotes y, por lo tanto, el argumento

04:19.410 --> 04:25.090
de entrada aquí es este lote que contendrá varias entradas y luego varios objetivos que se computarán.

04:25.500 --> 04:26.730
Entonces ahí vamos

04:26.730 --> 04:28.310
Ese es el único argumento que necesitamos.

04:28.500 --> 04:32.280
Ahora entremos en una función y definamos lo que necesitamos hacer.

04:32.370 --> 04:40.140
Entonces, como vimos en la Basílica del papel, necesitamos de nuevo los parámetros, así que dijimos que comenzamos

04:40.440 --> 04:45.390
introduciendo este parámetro gamma semicerrado y ya podemos descifrar el valor.

04:45.450 --> 04:51.780
Y vamos a elegir cuatro puntos noventa y nueve, que es un buen valor clásico para Ghana y Norreys.

04:51.780 --> 04:55.640
Comprobé que este es un buen valor para nuestra IA.

04:55.650 --> 05:04.120
Muy bien, el siguiente paso El siguiente paso es preparar nuestra contribución y nuestros objetivos porque eso es exactamente lo

05:04.120 --> 05:05.260
que queremos devolver.

05:05.260 --> 05:08.980
Queremos devolver las entradas a los objetivos para preparar la capacitación.

05:08.980 --> 05:15.520
lista y eso es cuando inicializamos las entradas como una lista, así como los objetivos a los que vamos.

05:15.790 --> 05:21.130
Y entonces ya podemos inicializarlos con una lista vacía porque, por supuesto, estas entradas Dentro

05:21.430 --> 05:25.000
de lo mejor vamos a tener varias entradas en una

05:25.000 --> 05:31.420
Entonces, inicializamos y colocamos nuestros objetivos y, al final, esta función de rastreo de elegibilidad

05:31.540 --> 05:33.320
devolverá exactamente estas entradas.

05:33.330 --> 05:36.180
Y estos sí fueron por supuesto Filton.

05:36.290 --> 05:42.300
Tenemos varias entradas y varios objetivos asociados en lo que será devuelto por la función.

05:42.300 --> 05:48.820
Bien, el siguiente paso es comenzar un ciclo y eso es exactamente porque estamos siguiendo el

05:48.880 --> 05:50.290
código lento del documento.

05:50.290 --> 05:51.400
Este tipo de código.

05:51.490 --> 05:58.420
Y como pueden ver, está esta sección de código de repetición y repite exactamente un ciclo completo en el código.

05:58.470 --> 06:03.870
Vamos a calcular la recompensa acumulada aquí acumulada en los 10 pasos.

06:03.940 --> 06:05.130
¿Y cómo se calcula?

06:05.290 --> 06:10.480
Bueno, en cada paso que no es el último paso vamos a obtener el máximo de los valores básicos de la moneda

06:10.480 --> 06:13.070
en la que estamos durante esto y los pasos se ejecutan.

06:13.240 --> 06:17.790
Y si alcanzamos bien el último estado de los 10 pasos, esto será igual a cero.

06:17.890 --> 06:19.810
Es decir que no queremos hacerlo más.

06:20.080 --> 06:23.320
Y luego tenemos esto para el ciclo que va a ser otro.

06:23.470 --> 06:28.390
No dicen que se repita aquí, pero es lo mismo que será el segundo ciclo completo en nuestro algoritmo.

06:28.600 --> 06:34.570
Bien, tendremos que ser así, multiplicándolo por el parámetro de degradación gamma y agregando

06:34.840 --> 06:35.660
la palabra.

06:36.010 --> 06:41.510
Así que hagámoslo, volvamos a Python y comencemos nuestro pleno, así.

06:41.980 --> 06:44.920
Y cuál va a ser la variable iterativa.

06:45.070 --> 06:47.820
Bueno, esa va a ser nuestra serie de 10 pasos.

06:47.890 --> 06:55.510
a llamar a esta serie de variables que representan una serie de 10 transiciones, como una secuencia de 10 transiciones.

06:55.600 --> 06:58.820
Conoces nuestra serie de 10 transiciones, así que vamos

06:58.860 --> 07:00.910
Entonces para series en.

07:01.210 --> 07:02.400
Y entonces, ¿qué piensas?

07:02.620 --> 07:05.570
Bueno, nuestra serie se reducirá a nuestro lote.

07:05.680 --> 07:12.040
Existen los lotes en los que se entrenarán las series de AI y demás en lotes que son para todas las series

07:12.040 --> 07:14.540
de 10 transiciones en nuestro lote de entrada.

07:14.800 --> 07:20.710
Bien, ¿dónde vamos a hacer bien para obtener una recompensa acumulativa, verá en la sílice que necesitamos el estado

07:20.950 --> 07:26.560
de la primera transición de la serie y también el estado de la última transición de la serie.

07:26.740 --> 07:33.040
Entonces, lo que tenemos que hacer ahora es obtener estos estados de entrada y, por lo tanto, vamos a

07:33.130 --> 07:39.380
poner estos dos estados en un estado viable que llamaría entrada y obtendremos estos dos estados de entrada.

07:39.400 --> 07:46.590
La primera de la serie y la última que vamos a poner en una matriz no piloto, pero no te preocupes, no

07:46.800 --> 07:51.880
se quedará con esto y Ampyra, por supuesto, convertirá eso en un horrible, pero el

07:51.880 --> 07:56.930
primer paso es poner estos dos declara el primero en el último en un imperio.

07:57.240 --> 08:03.850
serie, que es Series, y luego, para tomar una transición, tomamos el índice cero de la serie, esa es

08:03.850 --> 08:10.820
la primera transición y luego podemos acceder tomando sus atributos que es el estado y eso es porque en nuestra

08:10.820 --> 08:17.780
experiencia el archivo de reproducción encontramos una estructura especial para cada una de las transiciones y usted conoce la estructura.

08:18.290 --> 08:24.200
Y aquí en este arreglo agregamos la primera entrada, que es la etapa de entrada de la

08:24.440 --> 08:25.660
primera transición de la

08:25.730 --> 08:29.380
Cada transición se compone de un estado y una palabra de acción.

08:29.570 --> 08:34.970
Pero luego, el último elemento que se hace, por lo que esta estructura especial que estamos autorizados a usar en este

08:35.240 --> 08:39.250
momento proviene de la forma en que definimos la transición y la repetición de la experiencia.

08:39.290 --> 08:45.380
Está bien, así que con esto obtenemos el estado de entrada de la primera transición y ahora también podemos obtener

08:45.380 --> 08:48.640
la etapa de entrada de la última transición de la serie.

08:48.800 --> 08:57.200
acceder con este truco menos una serie menos una que el estado obtendrá el estado de entrada de la última transición de la serie.

08:57.200 --> 09:04.040
Y para hacer eso es para decir que podemos simplemente copiar esto y pegarlo y reemplazarlo como está aquí por

09:04.100 --> 09:07.420
el último índice de la serie al que podemos

09:08.210 --> 09:16.310
Está bien, entonces tenemos que poner estos dos elementos dentro de corchetes porque eso es lo que el árbitro espera que

09:16.310 --> 09:23.120
sea una función y luego algo importante que hacer ya que vamos a convertir eso en una respuesta

09:23.210 --> 09:26.140
de antorcha en una variable de antorcha.

09:26.330 --> 09:31.810
Bueno, recuerda que un tensor de antorcha es, por definición, una matriz especial que contiene un solo tipo.

09:31.940 --> 09:34.640
Y entonces necesitamos forzar tener un solo tipo.

09:34.760 --> 09:42.020
elegir el tipo de flotante, y así sucesivamente, agregando este parámetro aquí, D type equals y P que flotan.

09:42.750 --> 09:45.030
Y, como de costumbre, vamos a

09:45.320 --> 09:52.380
Para que pueda tomar este y ahora podemos convertirlo en un tensor de antorcha en un voivoda de antorcha.

09:52.550 --> 09:54.640
Así que hagamos esto, hagamos esto.

09:54.770 --> 09:57.470
Bueno, primero vamos a convertir eso en un sensor de antorcha.

09:57.590 --> 10:06.880
Y recuerde que podemos usar torche que desde el no primo que vamos y ponemos toda la matriz de los dos estados de

10:06.900 --> 10:15.180
entrada dentro de esta antorcha con la antorcha de ellos por una función perfecta que convertirá estas matrices de los dos

10:15.250 --> 10:18.230
estados de entrada en una antorcha sensor.

10:18.420 --> 10:26.560
la respuesta en una antorcha muy bien usando la clase de variable para que la entrada sea un objeto de la valiosa clase.

10:26.560 --> 10:28.400
Y ahora ponemos esta antorcha

10:28.480 --> 10:35.380
Y, de hecho, como usted entendió, esta clase variable toma todo esto como argumento y eso

10:35.380 --> 10:36.680
crea el objeto.

10:36.680 --> 10:38.420
Está bien, ahora deberíamos estar bien.

10:38.450 --> 10:41.000
Tenemos nuestras dos entradas que necesitamos.

10:41.000 --> 10:45.440
Ese es el estado de entrada de la primera transición y luego ingresa decir que es la última transición.

10:45.770 --> 10:51.890
Y ahora que tenemos las entradas Bueno, ¿qué podemos obtener? Podemos obtener la señal de salida del cerebro de

10:51.890 --> 10:52.560
la IA.

10:52.640 --> 10:56.160
Esa es la predicción de que vamos a llamarlo salidas.

10:56.630 --> 10:57.950
Esa es la señal de salida.

10:58.130 --> 10:59.280
Y para obtener los resultados.

10:59.330 --> 11:04.670
Bueno, ahora eso es muy fácil porque ya tenemos un cerebro creado que es nuestra red

11:04.670 --> 11:05.330
neuronal convolucional.

11:05.570 --> 11:14.120
Y entonces podemos simplemente tomar nuestra CNN del cerebro aplicada a las entradas que devolverá la predicción de que el

11:14.120 --> 11:16.650
resultado es tan simple como eso.

11:16.820 --> 11:19.510
Y ahora ya estamos listos para pasar al siguiente paso.

11:20.730 --> 11:24.890
Y el siguiente paso es comenzar a calcular esta comunidad si lo desea.

11:25.090 --> 11:30.690
Así que ahora vamos a hacer exactamente lo mismo que en algoritmo Sarsour o deberíamos llamarlo

11:30.760 --> 11:32.300
así como pasos para aprender.

11:32.290 --> 11:39.990
Vamos a presentar la variable de recompensa acumulativa, que será la recompensa acumulativa, regresemos al documento, como puede ver ahora mismo,

11:39.990 --> 11:45.120
lo que tenemos que hacer para obtener la recompensa de esta comunidad, que es

11:45.210 --> 11:46.000
nuestra aquí.

11:46.170 --> 11:53.160
agregando un cero a esta comunidad si lo fuésemos si alcanzáramos la última etapa de la serie o el máximo de los valores

11:53.160 --> 11:59.910
centrales si no hubiésemos llegado a la última etapa de la serie. la serie que es para todas las estáticas que duró.

12:00.000 --> 12:03.410
Bueno, y cada paso de los 10 pasos ejecutados necesitamos actualizarlo

12:03.750 --> 12:05.890
Entonces eso es simplemente una bonanza.

12:06.000 --> 12:07.580
Regresemos a Piscean.

12:07.650 --> 12:16.490
Entonces, esta recompensa de comunidad como acabamos de ver va a ser igual a cero punto cero si alcanzamos el último

12:16.490 --> 12:23.070
estado y podemos escribir esta condición de esta manera si series de índice menos 1.

12:23.070 --> 12:25.940
Esa es la última transición de la serie.

12:26.250 --> 12:32.280
que definimos en la experiencia. Jugamos que nuestra experiencia se repite y esto viene de las estructuras

12:32.280 --> 12:38.400
de apertura porque si vamos al sitio web abierto de Allergan que es realmente correcto aquí lo preparé.

12:38.400 --> 12:44.550
Luego agregamos que hecho porque hecho en realidad es un atributo de usted que conoce esta estructura

12:44.550 --> 12:45.240
de transición

12:45.280 --> 12:47.160
Eso es hacer el bien o Visir.

12:47.340 --> 12:52.300
Y si vamos a la documentación y luego si nosotros.

12:52.380 --> 12:55.240
Ese es el tutorial que realmente te animo a echarle un vistazo.

12:55.470 --> 13:01.530
Puede ejecutar un entorno que Knowsley puede ver que nuestras observaciones de que estas

13:01.950 --> 13:04.690
son transiciones están definidas por una observación.

13:04.790 --> 13:12.150
Queremos que esto se haga aquí y esto significa exactamente que una transición o un paso ha terminado.

13:12.150 --> 13:15.440
Y entonces vamos a usar esto aquí para nuestra condición IF.

13:15.610 --> 13:23.460
Por lo tanto, la locura de iSeries cuando eso se hace significa que se ha completado la última transición de la serie.

13:23.730 --> 13:29.290
Entonces, esta recompensa acumulativa va a ser igual a cero si se realiza la última transición de la serie.

13:29.330 --> 13:37.290
De lo contrario, si no hemos llegado a la última transición, la recompensa acumulativa se actualizará

13:37.290 --> 13:40.950
con el máximo de los valores clave.

13:41.220 --> 13:47.460
Y dado que esta salida aquí es la salida del cerebro que son las predicciones de la red neuronal.

13:47.520 --> 13:53.640
Y como saben, las predicciones de la red neuronal son los valores predichos Bueno, esta salida

13:53.920 --> 13:55.040
contiene los valores.

13:55.110 --> 14:01.130
Y dado que necesitamos tomar bien el máximo de los valores q, necesitamos agregar primero este índice

14:01.130 --> 14:04.620
porque esta estructura contiene dos valores clave y el siguiente.

14:04.620 --> 14:07.830
Y luego tenemos que agregar datos para acceder a los datos.

14:07.830 --> 14:12.150
Esta estructura de salida que usted conoce tiene la estructura especial de un voivoda de antorcha.

14:12.270 --> 14:17.910
Así que con esto obtenemos nuestros valores centrales y luego queremos tomar el máximo de nuestros valores

14:17.910 --> 14:20.470
de cue y por eso agregamos que Max.

14:20.490 --> 14:27.820
Y ahora obtenemos exactamente lo que queremos, como en el documento este máximo de los valores de cubo para

14:27.820 --> 14:30.240
los estados no terminales como perfecto.

14:30.280 --> 14:33.460
Y entonces, lo que vamos a hacer es hacer el segundo doblez.

14:33.930 --> 14:40.830
Es decir, para los 10 pasos de la serie, vamos a actualizar el acumulado de esta manera, multiplicando primero

14:40.830 --> 14:46.170
por Gamma el parámetro de disminución que ya tenemos y luego agregamos la palabra B.

14:46.410 --> 14:47.540
Entonces, hagamos esto.

14:47.610 --> 14:52.260
De hecho, vamos a hacer exactamente lo mismo que en el pseudocódigo, ya que puede notar que comienzan

14:52.260 --> 14:52.970
desde la derecha.

14:53.040 --> 14:59.010
Entonces no están comenzando con el primer paso y van a la última prueba que comienzan con el último paso.

14:59.040 --> 15:02.280
T-menos 1 al primer paso para comenzar.

15:02.340 --> 15:06.520
Eso es exactamente lo que vamos a hacer y es porque queremos

15:06.610 --> 15:15.840
obtener al final la recompensa acumulada igual a nuestros iguales o cero más gamma o 1 más gamma cuadrado o dos más esa gamma agregada más

15:15.840 --> 15:24.420
a la potencia de 10 o 10 donde son 1 o 2 que son 10 son la palabra obtenida en cada uno de los

15:24.420 --> 15:25.580
pasos de la serie.

15:25.590 --> 15:29.870
Tomemos un descanso rápido antes de tomar el segundo ciclo completo y nos vemos en el siguiente tutorial.

15:30.030 --> 15:31.530
Hasta entonces, disfruta de la IA.
