WEBVTT

00:00.240 --> 00:06.600
Hola y bienvenidos a este tutorial de Python en Statoil, vamos a dar el primer paso para

00:06.630 --> 00:08.270
implementar el modelo teórico profundo.

00:08.280 --> 00:13.590
Entonces, básicamente, estamos a punto de implementar todo el proceso del algoritmo de difusión.

00:13.830 --> 00:16.580
Y entonces vamos a usar lo que creamos antes.

00:16.590 --> 00:22.460
Esa es la arquitectura de la red neuronal para reproducir la memoria para integrar esto en todo el

00:22.530 --> 00:24.180
proceso de aprendizaje de dequeue.

00:24.180 --> 00:28.320
Y todo este algoritmo de aprendizaje encajará en una sola clase.

00:28.380 --> 00:32.340
Es lo último que estamos haciendo para implementar inteligencia artificial.

00:32.340 --> 00:35.650
Y esta clase solo contendrá diferentes funciones.

00:35.700 --> 00:41.790
Así que tendremos las funciones en él que crearán e inicializarán todas las variables adjuntas

00:41.790 --> 00:48.450
a nuestros futuros objetos de desvío que representarán el modelo en sí y tendrán algunas otras funciones.

00:48.510 --> 00:52.830
Uno de ellos será, por supuesto, seleccionar la acción correcta en cada momento.

00:52.950 --> 00:59.250
También tendremos una función central de función de actualización para obtener este núcleo y tener una idea de cómo

00:59.250 --> 01:01.030
va el aprendizaje si va bien.

01:01.090 --> 01:07.080
Si la exploración está yendo bien y si puede pasar a la explotación, entonces tendremos una función

01:07.080 --> 01:12.430
segura para salvar mañana que es salvar el cerebro del automóvil y luego cargar la función.

01:12.480 --> 01:14.590
Entonces tenemos un par de funciones para hacer.

01:14.640 --> 01:17.440
Vamos a hacer una función para que cada uno trabaje.

01:17.490 --> 01:22.820
Y hoy vamos a comenzar con la función final como de costumbre cuando estamos haciendo una clase.

01:23.010 --> 01:30.040
Pero primero no olvidemos presentar la clase, así que vamos a llamarla D.

01:30.200 --> 01:35.970
Q Y para su red, entonces algunos paréntesis llaman.

01:36.030 --> 01:39.440
Y luego vamos con nuestra primera función.

01:39.500 --> 01:47.910
Así que hagamos esta def entonces doblar el guión bajo y luego su doble guión de subrayado y paréntesis.

01:48.170 --> 01:53.530
Entonces, como usted entendió en esta función, vamos a presentar las variables adjuntas a nuestro objeto.

01:53.570 --> 01:59.240
Así que vamos a tener un par de líneas comenzando por nosotros mismos y básicamente crearemos e

01:59.300 --> 02:03.530
iniciaremos todas las variables que se necesitan para implementar la red D2.

02:03.530 --> 02:09.740
Así que, por ejemplo, crearemos un objeto o una red porque, por supuesto, necesitamos nuestra red neuronal

02:10.310 --> 02:12.190
profunda, entonces necesitaremos nuestra memoria.

02:12.300 --> 02:14.630
Crearemos otra variable para la memoria.

02:14.740 --> 02:20.430
Así que tendremos otra memoria variable, pero eso no es todo lo que tendremos que crear también.

02:20.480 --> 02:22.390
Algunas variables para la última fecha.

02:22.490 --> 02:24.820
La última acción y la última palabra.

02:24.920 --> 02:30.520
Por supuesto, usted conoce las variables que ve en el algoritmo de difusión.

02:30.920 --> 02:31.830
Y luego qué más.

02:31.940 --> 02:38.150
Bueno, también necesitaremos un optimizador que conozca para realizar una cuadrícula estocástica en el sentido

02:38.510 --> 02:42.170
de ponderación de datos según cuánto contribuyan al error.

02:42.320 --> 02:48.650
Cuando la IA está cometiendo un error y creo que eso es básicamente las variables que ahora

02:48.650 --> 02:50.230
necesitamos crear e inicializar.

02:50.510 --> 02:58.460
Pero en esta función de inicio pondremos primero un par de argumentos como de costumbre, que son los argumentos que se

02:58.460 --> 03:00.190
refieren a nuestro objeto.

03:00.200 --> 03:05.210
Entonces, como sabes, vamos a crear un objeto de la clase de red.

03:05.390 --> 03:12.740
Bueno, ya que la clase de red toma como argumento el tamaño de entrada de la función init y la acción Bueno, aquí

03:12.740 --> 03:13.740
es lo mismo.

03:13.850 --> 03:19.110
Al crear un objeto de la clase de red, tendremos que elegir un argumento de tamaño de entrada

03:19.160 --> 03:20.180
y el argumento real.

03:20.180 --> 03:22.140
Por lo tanto, podemos copiarlos

03:25.660 --> 03:27.520
aquí y aquí vamos.

03:27.710 --> 03:30.450
Entonces estos argumentos se volverán ahora.

03:30.560 --> 03:33.160
También algunos argumentos no duraron.

03:33.170 --> 03:39.680
Cada vez que creamos algunos objetos futuros de la clase diferente que algunos futuros modelos de roles dicales Bueno, tendremos

03:39.680 --> 03:45.010
que especificar el tamaño de entrada que recuerdo es la cantidad de dimensiones en los vectores

03:45.010 --> 03:46.330
que incluyen sus estados.

03:46.370 --> 03:52.940
Su entrada de estados y una serie de acciones que es la cantidad de acciones posibles que puede realizar el automóvil.

03:53.150 --> 03:54.000
Así que te lo recuerdo.

03:54.110 --> 03:57.830
Estos son o bien, ir a la izquierda, seguir recto o ir a la derecha.

03:58.190 --> 03:59.270
Bien perfecto.

03:59.270 --> 04:04.640
Entonces sabrá que va a crear un nuevo objeto de la clase de memoria de repetición para crear

04:04.640 --> 04:10.680
el objeto de memoria para obtener nuestra memoria de las transiciones y en la información tenemos el argumento de capacidad.

04:10.850 --> 04:16.640
Pero ya que solo lo usaremos una vez en realidad cuando creamos memoria y no en

04:16.640 --> 04:20.000
el futuro Bueno, no necesitaremos especificar el argumento de capacidad.

04:20.030 --> 04:25.330
Podríamos hacer esto pero ingresaremos directamente la cantidad de transiciones que queremos que tenga nuestra memoria.

04:26.150 --> 04:32.390
Pero luego necesitamos un último argumento que sea obtener el parámetro en el modelo del docente.

04:32.480 --> 04:35.470
Recuerde que este parámetro gamma es la demora.

04:35.750 --> 04:41.300
parámetro de la ecuación y, por lo tanto, lo pondremos aquí porque lo usaremos después varias veces.

04:41.510 --> 04:42.920
Y ese es un

04:43.160 --> 04:44.990
Así que pongámoslo aquí.

04:45.070 --> 04:47.140
Vamos a llamarlo Gamma.

04:47.150 --> 04:52.610
Entonces para eso es solo el nombre del argumento y luego vamos a todos los argumentos que necesitarás para

04:52.610 --> 04:53.740
esto en su función.

04:53.750 --> 05:00.320
Entonces eso significa que siempre que creamos nuestro modelo de diccionario es siempre que creamos un objeto del

05:00.320 --> 05:01.390
profesor en clase.

05:01.520 --> 05:08.060
Bueno, tendremos que especificar como argumentos el tamaño de la entrada, el número de acción y el parámetro.

05:08.360 --> 05:10.590
Y terminaremos con los valores reales para ellos.

05:11.210 --> 05:13.870
Muy bien, ahora vamos a entrar en la función.

05:14.100 --> 05:14.400
DE ACUERDO.

05:14.410 --> 05:16.480
Entonces, básicamente, esto va a ser fácil.

05:16.510 --> 05:21.090
Estamos a punto de crear e inicializar todas las variables que necesitamos.

05:21.110 --> 05:22.770
Y entonces comencemos con el primero.

05:22.910 --> 05:24.460
Comencemos con gamma.

05:24.530 --> 05:26.090
En realidad, el coeficiente de retraso.

05:26.330 --> 05:31.850
Entonces, como se trata de un voivoda que quiere apegarse a su objeto, comenzamos por nosotros mismos.

05:31.880 --> 05:39.500
Entonces gamma va a ser una variable de nuestro maestro y se modelará a sí mismo que gamma es igual a los argumentos que

05:39.530 --> 05:42.930
se ingresarán al crear un objeto de la clase de desafinación.

05:42.950 --> 05:46.900
Entonces Janna y ahi vamos con el segundo argumento.

05:47.040 --> 05:50.560
El segundo argumento será la ventana de recompensa.

05:50.840 --> 05:52.340
Entonces, ¿qué es esta ventana?

05:52.520 --> 05:57.950
deslizante de la media de las últimas 100 palabras que usará solo para evaluar la evolución del

05:58.010 --> 06:04.280
rendimiento que sabe que tendrá el significado de la palabra en esta guerra Windu que se deslizará con el tiempo.

06:04.280 --> 06:06.320
Bueno, esa va a ser la ventana

06:06.440 --> 06:11.680
Y lo que queremos observar es el significado de las últimas 100 palabras que aumentan con el tiempo.

06:11.930 --> 06:18.610
Así que vamos a inicializarlo con uno mismo que recompensa la ventana de subrayado.

06:18.710 --> 06:24.690
Y así que esto va a ser una ventana deslizante de la media en evolución de las últimas 100 palabras.

06:24.860 --> 06:31.710
Bueno, vamos a inicializarlo como una lista vacía y luego nos expandiremos para indicar que trabajamos horas extras.

06:32.860 --> 06:35.320
Muy bien, entonces más emocionante.

06:35.420 --> 06:37.430
Vamos a crear nuestra red neuronal.

06:37.580 --> 06:43.780
Así que vamos a llamarlo Mario autodidacta porque básicamente ese es el corazón de las modelos.

06:43.790 --> 06:51.890
Lo llamo modelo y este modelo no será más que un tema de esa clase y

06:51.890 --> 06:53.270
creará tal objeto.

06:53.300 --> 07:02.630
Tomamos nuestra red de clase entre paréntesis y aquí simplemente ponemos los argumentos de la clase pero ponemos estos argumentos en los

07:02.750 --> 07:08.930
argumentos de la función init y por lo tanto solo tenemos que copiarlos aquí y

07:08.930 --> 07:15.290
simplemente pegarlos en la clase de red y luego ir con esta línea de código.

07:15.350 --> 07:22.690
Creamos una red neuronal para el modelo de aprendizaje perfecto, entonces creemos una memoria.

07:22.880 --> 07:29.930
Así que de nuevo vamos a crear un nuevo Vargo que llamamos memoria autodidacta.

07:29.930 --> 07:34.190
Y de nuevo, este va a ser un objeto de la clase de memoria de repetición.

07:34.220 --> 07:42.320
Así que tomemos el nombre o la clase copiemos sin embargo, enfrentémoslo aquí y en algunos paréntesis tenemos que poner la

07:42.320 --> 07:48.680
capacidad porque la capacidad es un argumento de la función y ese es el único argumento

07:48.680 --> 07:49.880
que necesitamos aquí.

07:50.240 --> 07:55.100
Entonces, ¿qué capacidad vamos a elegir? Recuerda que corresponde al número de transiciones al número de

07:55.100 --> 07:59.800
eventos del último estado en el que declaraste la última acción y la última palabra.

07:59.830 --> 08:07.550
Y así como se menciona en uno de los trabajos de Priester, vamos a tomar cien mil cien mil

08:07.550 --> 08:14.390
transiciones en la memoria y luego tomaremos muestras de esta memoria para obtener un pequeño número de

08:14.390 --> 08:18.670
transiciones aleatorias y en las que el modelo estará bien.

08:18.720 --> 08:21.210
Entonces ahora tenemos nuestra memoria perfecta.

08:21.210 --> 08:23.180
Ahora consigamos nuestro optimizador.

08:23.430 --> 08:31.800
Así que, una vez más, creamos una nueva variable que llamamos optimizador, por lo que el optimizador es otra variable de

08:31.800 --> 08:35.320
nuestro futuro. Dequeue un objeto que sea ese optimizador.

08:35.520 --> 08:44.130
Y ahora si volvemos a subir podemos ver que importamos Upton torturado, que es una antorcha modular que contiene todas las herramientas para llevar a

08:44.160 --> 08:47.080
cabo para obtener la cuadrícula en el centro.

08:47.130 --> 08:54.260
optimizadores y le dimos el atajo Upton y, por lo tanto, lo que vamos a hacer es llevarle el

08:54.270 --> 09:00.900
modelo, que es antorcha, depende de él y de este módulo vamos a tomar uno de los optimizadores.

09:00.900 --> 09:03.060
Así que, por supuesto, contiene algunos

09:03.180 --> 09:05.670
Entonces, como puede ver, todos están listados aquí.

09:05.880 --> 09:10.630
Muchos de ellos son excelentes, por ejemplo, Propp de armadura es un excelente optimizador.

09:10.640 --> 09:16.170
Por ejemplo, es muy recomendable para un registro de redes neuronales o aprendizaje profundo no supervisado.

09:16.230 --> 09:22.140
Pero el otro que es excelente y que elegirá es el optimizador de átomos.

09:22.500 --> 09:26.400
Ese es el que verá que con este obtendrá un buen auto sin conductor.

09:26.580 --> 09:32.000
Pero de nuevo, eres totalmente bienvenido a probar otros, puedes probar el propulsor de armas, pero para metal

09:32.000 --> 09:32.810
elegiremos a Adam.

09:32.850 --> 09:34.290
Así que presiono enter.

09:34.560 --> 09:37.240
Y de hecho notarás que aquí está el capitolio.

09:37.260 --> 09:40.430
Eso es porque estamos creando un objeto de la clase Atom.

09:40.430 --> 09:44.990
Esta es una clase pero el objeto será un optimizador de átomos en sí mismo.

09:45.060 --> 09:50.970
Pero dado que esta es una clase, necesitamos poner algunos argumentos en los argumentos de la clase Atom

09:51.060 --> 09:55.270
y los argumentos son todos los parámetros que pueden personalizar su y optimizador.

09:55.380 --> 10:00.330
Entonces, por ejemplo, esa es la velocidad de aprendizaje, la disminución o algunos otros parámetros.

10:00.510 --> 10:05.690
Y además de tomar todos los parámetros de Ormeau, especificaremos una tasa de aprendizaje.

10:05.970 --> 10:08.650
Entonces es el comienzo de los parámetros de nuestro modelo.

10:08.670 --> 10:12.830
Podemos obtenerlos con el modelo de duda.

10:12.870 --> 10:17.530
Entonces ese es el modelo que creamos aquí modelo autodidacta de nuestra propia clase.

10:17.580 --> 10:24.780
Entonces modelo autodidacta y luego para acceder a los parámetros del modelo agregamos otro punto y luego los

10:25.500 --> 10:28.170
parámetros con algunos paréntesis muy simples.

10:28.170 --> 10:35.860
Así que eso es solo para conectar el optimizador de complementos a nuestra red neuronal, el que creamos aquí nuevamente,

10:35.880 --> 10:42.810
como acabamos de mencionar, vamos a agregar una tasa de aprendizaje y el argumento para esto es nuestro.

10:43.170 --> 10:50.540
el aprendizaje no suceda demasiado rápido si obtenemos una tasa de aprendizaje demasiado grande para que la AI AI aprenda correctamente.

10:50.540 --> 10:53.910
Y lo configuraremos igual a un valor tal que

10:53.910 --> 10:58.890
Queremos darle a nuestra IA algún tiempo para explorar y aprender de sus errores.

10:58.890 --> 11:04.320
Sabes cuándo lo castigamos cuando comete errores, como entrar en algún sentido o acercarse demasiado

11:04.320 --> 11:05.510
a una pared.

11:05.770 --> 11:08.780
Bueno, queremos dar algo de tiempo para aprender.

11:08.880 --> 11:12.030
Queremos un camino hacia la red neuronal para la fecha correcta.

11:12.180 --> 11:21.010
Entonces, un buen valor para la tasa de aprendizaje con la que terminé después de probar varios de ellos es 0. 2 o uno.

11:21.210 --> 11:24.540
Está bien y eso es todo lo que necesitamos para crear un optimizador.

11:24.720 --> 11:28.320
Entonces, básicamente estás creando un objeto de la clase Atom.

11:28.530 --> 11:29.050
Estupendo.

11:29.070 --> 11:35.980
Y luego las últimas tres variables que necesitamos son las variables que componen nuestros eventos de transición.

11:36.150 --> 11:40.130
Entonces esa es la última fecha de la última acción y la última palabra.

11:40.170 --> 11:45.280
Y eso es básicamente lo que crearemos ahora y solo tendremos que inicializarlos.

11:45.300 --> 11:50.130
Comencemos con la última fecha, la última fecha en que la llamaremos autodidacta.

11:50.400 --> 11:56.000
Último subrayado de estado y luego cómo vas a inicializarlo.

11:56.190 --> 12:03.840
que la última fecha es un vector de 5 dominaciones, un vector codificado en un estado del entorno.

12:03.840 --> 12:04.700
Bueno, recuerda

12:04.950 --> 12:10.800
Y a modo de recordatorio, estas cinco dimensiones son las tres señales de los tres sensores que se

12:10.800 --> 12:15.180
dejan en posición recta y derecha, y la orientación y la orientación negativa.

12:15.210 --> 12:18.350
Entonces este es un vector y un sentido intuitivo.

12:18.420 --> 12:21.060
Pero para la antorcha tiene que ser más que un vector.

12:21.210 --> 12:23.640
Realmente necesita ser un tensor de antorcha.

12:23.820 --> 12:29.970
Pero no solo necesita ser un sensor de antorcha sino que también necesita tener una dimensión más

12:29.970 --> 12:33.510
que me gusta llamar dimensión falsa que corresponde al lote.

12:33.630 --> 12:39.810
Y eso es porque los últimos ocho serán la entrada de la red neuronal, pero al trabajar conmigo cuando eso

12:39.810 --> 12:46.220
funciona en general, ya sea con flujo más denso, lleva una antorcha, mientras que los vectores de entrada no pueden ser

12:46.290 --> 12:48.040
un vector simple por sí mismo.

12:48.210 --> 12:49.760
Tiene que estar en un lote.

12:49.830 --> 12:57.660
La red solo puede aceptar lotes de observaciones de entrada y, por lo tanto, no solo creará un

12:57.870 --> 13:05.140
tensor para vectores de estado de entrada sino que también crearemos esta dimensión falsa correspondiente al lote.

13:05.190 --> 13:11.490
Así que hagámoslo y comencemos inicializando un tensor de antorcha, para hacer esto no hay nada

13:11.490 --> 13:12.340
más simple.

13:12.510 --> 13:21.810
Tomamos nuestra biblioteca de torche, luego dotamos y luego vamos a usar la clase de tensor porque, como habrás adivinado,

13:21.810 --> 13:27.950
esto creará un objeto de la clase de tensor que es un objeto tensor.

13:28.120 --> 13:34.660
Y en este tensor debemos poner un argumento que especifique el tamaño del tensor.

13:34.660 --> 13:38.720
Puedes imaginar que te lleva como una matriz con un solo tipo.

13:38.890 --> 13:45.430
Pero básicamente, lo que esto representará ahora es, por supuesto, este estado de entrada que puedes ver tiene un vector y

13:46.180 --> 13:49.380
así especificar el número de elementos que la distancia debe tener.

13:49.570 --> 13:55.180
Bueno, tenemos que usar, por supuesto, el tamaño de entrada porque el tamaño de entrada es exactamente el número de dimensiones

13:55.510 --> 13:57.520
de nuestros vectores de estado de entrada.

13:57.520 --> 13:59.050
Ahora debería decir tensores.

13:59.170 --> 14:05.650
Y entonces, lo que necesitamos simplemente es ingresar en nuestra clase de tensores para crear un objeto tensor.

14:06.010 --> 14:07.260
Bueno, eso es impreciso.

14:07.540 --> 14:10.230
Y más adelante se cuantificará el tamaño de entrada.

14:11.350 --> 14:12.430
De acuerdo, eso está bien.

14:12.430 --> 14:13.670
Eso es lo primero que se hace.

14:13.720 --> 14:17.390
Acabamos de inicializar el tensor como debería ser.

14:17.530 --> 14:23.080
daño que usted poner en el lote será la primera vez que menciono esto digamos muy bien.

14:23.080 --> 14:30.070
Pero recuerde que tenemos que hacer otra cosa para crear esa dimensión falsa porque esto es lo que la red

14:30.070 --> 14:35.840
espera de sus entradas y crear esta para su examen, que por cierto tiene que ser la

14:35.940 --> 14:37.800
primera vez que conoce el

14:38.230 --> 14:46.050
Bien para hacer esto, simplemente tenemos que agregar eso luego, exprimir y luego encerrar entre paréntesis.

14:46.050 --> 14:49.580
Necesitamos poner el índice de esta gran dimensión.

14:49.620 --> 14:55.790
Y como acabo de decir que esta dimensión falsa tiene que ser la primera animación de la última fecha y dado

14:55.790 --> 15:02.460
que los índices y bytes comenzaron en cero, necesitamos ingresar cero para que este nuevo motor de paradigma se convierta en el

15:02.460 --> 15:03.570
motor de primera línea.

15:03.570 --> 15:09.360
Así que tenemos un motor de primera vez que corresponde al lote y luego el diamante debe

15:09.360 --> 15:15.960
responder a ese sensor que contendrá los cinco elementos de su entrada indica la orientación de las tres señales y

15:15.990 --> 15:16.910
la orientación negativa.

15:17.370 --> 15:21.960
Y luego vamos, inicializamos nuestros estados de entrada correctamente.

15:21.960 --> 15:22.850
Perfecto.

15:23.310 --> 15:30.840
Y luego dos variables para ir y eso va a ser mucho más fácil porque la siguiente variable es la

15:31.110 --> 15:31.850
última acción.

15:32.190 --> 15:36.340
Eso es un nuevo Roybal que estamos creando para Object última acción.

15:36.510 --> 15:43.440
Y recuerda en el primer tutorial de la sección que te dije que las acciones van a

15:43.440 --> 15:52.470
ser 0 1 o 2 y luego usando el vector de rotación de acción convertiremos estos índices de estas acciones en los

15:52.470 --> 15:58.010
ángulos de la rotación que le recordamos a nuestro 0 20 o menos 20.

15:58.050 --> 16:00.980
De hecho, podemos refrescar nuestra memoria con eso.

16:01.200 --> 16:03.170
Bueno, está exactamente aquí.

16:03.170 --> 16:06.260
Acción para la rotación si la acción es cero.

16:06.390 --> 16:11.650
Bueno, esto corresponderá al primer índice de cero si la acción es 1.

16:11.700 --> 16:17.310
obtendremos menos 20 grados, que será el ángulo de rotación de nuestro automóvil cuando juguemos la acción.

16:17.310 --> 16:23.490
Esto corresponderá al índice uno de estos vectores de 20 grados y, si se trata de una acción,

16:23.510 --> 16:24.200
Todo bien.

16:24.380 --> 16:31.040
Y por lo tanto, dado que la acción va a ser 0 1 o 2 Bueno, la acción está ahí para un

16:31.040 --> 16:31.740
número simple.

16:31.850 --> 16:35.440
Y de manera muy simple, podemos inicializarlo a cero.

16:35.660 --> 16:38.330
No necesitamos crear decenas ni escuchar nada más.

16:38.360 --> 16:40.880
Solo tenemos que inicializarlo con cero.

16:41.420 --> 16:42.850
Y finalmente.

16:43.010 --> 16:44.460
Bueno, esa es la última palabra.

16:44.550 --> 16:48.840
Es el ser esa última palabra.

16:48.860 --> 16:49.940
Aquí vamos.

16:49.940 --> 16:56.510
Y de nuevo, la palabra es un número flotante que recuerdo que está entre menos 1 y más 1.

16:56.510 --> 16:57.790
Entonces ese es el número otra vez.

16:57.860 --> 16:59.400
Y en cuanto a la acción.

16:59.510 --> 17:02.900
Lo inicializaremos a cero y luego iremos.

17:02.900 --> 17:06.330
Felicitaciones, la función está lista.

17:06.350 --> 17:08.930
Así que ahora estamos listos para pasar a las cosas emocionantes.

17:08.930 --> 17:16.040
Y, de hecho, lo más importante para AI es decidir qué acción ejecutar en cada momento y cada tanty.

17:16.080 --> 17:23.240
Y eso es exactamente lo que vamos a hacer en el próximo tutorial al crear el método de acción selectivo.

17:23.510 --> 17:27.310
Así que hagamos esto en el siguiente trabajo y hasta entonces.