WEBVTT

00:00.360 --> 00:06.030
Hola y bienvenidos a la primera parte de la implementación de AI. Parte uno construyendo la IA.

00:06.120 --> 00:12.570
Y como pueden ver, ya agregué una dimensión en la estructura de esta sangría con estas tres secciones que componen

00:12.660 --> 00:16.620
la Parte 1, que muestran claramente cómo vamos a construir esta IA.

00:16.620 --> 00:18.750
Primero vamos a hacer el cerebro.

00:18.840 --> 00:23.760
No hay nada más que la red neuronal, entonces vamos a hacer el cuerpo que definirá cómo

00:23.760 --> 00:25.400
se van a jugar las acciones.

00:25.590 --> 00:31.620
Y una vez que tengamos el cerebro y el cuerpo, los reuniremos para hacer la IA que estará en

00:31.620 --> 00:33.840
la última sección de esta primera parte.

00:33.840 --> 00:37.890
Entonces, ahora ya puede tener una buena visión de la estructura de esta implementación.

00:37.890 --> 00:42.760
Primero hacemos el cerebro, luego hacemos el cuerpo y luego armamos los dos para hacer la IA.

00:43.050 --> 00:48.520
Y luego, esto es todo lo que vamos a comenzar con la primera sección que trata de hacer el cerebro.

00:48.810 --> 00:51.330
Y esto nos va a llevar a tutoriales.

00:51.360 --> 00:54.810
Puedes imaginar que hacer un cerebro no es como hacer un pastel.

00:54.900 --> 00:57.100
Entonces esto requerirá más de un tutorial.

00:57.270 --> 01:03.690
supuesto como de costumbre vamos a representar ese cerebro con una clase porque necesitaremos varias funciones

01:03.690 --> 01:10.200
y para tener una estructura de varias funciones que se organizarán en algún tipo de instrucciones.

01:10.200 --> 01:11.160
Y por

01:11.310 --> 01:16.010
Bueno, por supuesto, necesitamos una clase y esa es Berkeley porque una vez que hicimos esa clase.

01:16.080 --> 01:22.080
Bueno, podremos crear tantos cerebros como queramos creando solo algunos objetos de esta clase.

01:22.080 --> 01:28.050
Así que de nuevo las clases en Python y, en general, los lenguajes de programación orientados a objetos son muy

01:28.200 --> 01:33.510
prácticos porque usted hace un modelo de algo que desea construir y luego puede crear tantos objetos

01:33.510 --> 01:37.820
como desee y tendrán todas las características que usted necesita. definir en la clase.

01:38.010 --> 01:40.470
Y para nuestro cerebro, las características serán, por supuesto.

01:40.500 --> 01:45.930
de entrada a las neuronas de salida que serán, por supuesto, la función de Ford que hará.

01:45.930 --> 01:51.780
Bueno, ante todo la arquitectura de la red neuronal que recuerdo será de CNN y, por supuesto, dos

01:51.780 --> 01:55.520
funciones diferentes, como por ejemplo transmitir las señales de las neuronas

01:55.920 --> 01:58.940
Entonces, hagamos esto, comencemos a hacer el cerebro.

01:58.950 --> 02:00.600
Esto va a ser muy emocionante.

02:00.650 --> 02:02.380
Es una de mis partes favoritas

02:02.520 --> 02:04.860
Y, por lo tanto, vamos directo a eso.

02:04.890 --> 02:10.880
Así que vamos a comenzar presentando la clase por supuesto y vamos a llamar a esta clase.

02:10.950 --> 02:18.570
pero seamos más directos y llamémoslo CNN porque en realidad el cerebro es una red de CNN.

02:18.570 --> 02:20.570
Bueno, dudé en llamarlo cerebro,

02:20.580 --> 02:22.510
Red neuronal convolucional.

02:22.530 --> 02:27.440
Así que mientras miras puedes llamar al cerebro si quieres, pero al menos ahora sabemos lo que estamos construyendo.

02:28.710 --> 02:35.040
Y CNN En cuanto a la red del auto sin conductor heredará desde el final de Mudgal.

02:35.220 --> 02:42.870
Así que recuerda que el final del módulo es lo que ponemos aquí y queremos poder usar todas las herramientas

02:42.870 --> 02:49.050
de este y un módulo y, por lo tanto, queremos utilizar esta técnica en la programación

02:49.050 --> 02:55.870
orientada a objetos que es herencia y que nos permite conocerte usar todas las herramientas de una clase

02:55.900 --> 02:59.970
para padres y esta misma clase va a estar en ese módulo.

02:59.970 --> 03:00.830
Aquí vamos.

03:00.930 --> 03:05.510
Y ahora podemos usar todas las herramientas y objetos al final de ese módulo.

03:05.510 --> 03:12.100
Muy bien, ahora que tenemos nuestra herencia, podemos ingresar a la clase para realizar nuestra primera función.

03:12.150 --> 03:18.360
Y como probablemente adivine, la primera función es la función final que definirá todas las variables de

03:18.720 --> 03:20.330
los futuros objetos cerebrales.

03:20.370 --> 03:23.440
Usted sabe el futuro y los objetos que se crearán.

03:23.700 --> 03:24.890
Está bien, así que hagámoslo.

03:24.900 --> 03:29.800
Def luego dos subrayados en los puntajes de nuevo.

03:29.910 --> 03:31.910
Y ahora tenemos que poner algunas variables.

03:32.100 --> 03:37.460
Entonces, antes que nada, iba a ser yo mismo, por supuesto, para referirme al objeto.

03:37.490 --> 03:42.380
Ahora supongo que estás bastante cómodo con esto, entonces vamos a agregar otra variable que será

03:42.380 --> 03:45.310
el número de acciones en el entorno de Dumah.

03:45.500 --> 03:48.900
Entonces vamos a llamar a esas acciones numéricas.

03:49.010 --> 03:50.380
Cantidad de acciones

03:50.570 --> 03:54.390
Y en realidad esta variable no es obligatoria para la función.

03:54.500 --> 03:59.360
Es solo que si quieres probar la idea, vamos a construir en otros entornos.

03:59.540 --> 04:06.100
Bueno, esto será muy práctico porque importaremos este número de acciones horribles de los contenedores Doom

04:06.120 --> 04:12.290
y Varman con dos discretos y cuando lo hagamos sabremos ingresar el nombre del entorno

04:12.510 --> 04:13.980
haciendo el cero.

04:14.180 --> 04:21.050
Entonces, si quieres saber experimentar con esto en otros entornos y jugar bien a otros juegos, no tendrás nada

04:21.050 --> 04:26.300
que hacer porque este número de acciones obtendrá directamente el número de acciones en el

04:26.300 --> 04:27.470
entorno de Dumor.

04:27.470 --> 04:28.650
Estarás jugando con.

04:29.110 --> 04:32.710
OK, así que eso es todo por los dos argumentos de esta función.

04:32.780 --> 04:36.500
Entonces ahora podemos entrar y recordar lo que tenemos que hacer.

04:36.530 --> 04:41.560
Lo primero que tenemos que hacer es activar la herencia con la superfunción.

04:41.570 --> 04:43.840
Así que eso es exactamente como para el auto sin conductor.

04:43.970 --> 04:50.940
Tomamos la superfunción y luego adentro comenzamos ingresando la clase que definirá la red neuronal

04:51.470 --> 04:53.330
y que es CNN.

04:53.690 --> 04:56.950
Luego tenemos que ingresar a uno mismo para referirnos al objeto.

04:57.190 --> 05:05.230
Pero recuerde que no es todo lo que necesitamos agregar aquí en DOT y luego la función init con algunos paréntesis.

05:05.270 --> 05:07.880
Y al hacerlo, activamos la herencia.

05:07.950 --> 05:11.470
Y ahora podemos usar todas las herramientas desde el final y el módulo.

05:11.510 --> 05:17.070
Está bien, así que ahora creo que es hora de construir la arquitectura de la red neuronal.

05:17.270 --> 05:23.330
Y para que lo recuerden vamos a construir una red neuronal convolucional de CNN simplemente porque

05:23.330 --> 05:30.290
esta vez la IA tendrá ojos y los ojos del ojo serán las capas convolucionales de esta red

05:30.290 --> 05:31.220
neuronal convolucional.

05:31.520 --> 05:38.240
Y luego, después de que ai ai visualice las imágenes con las capas convolucionales, pasará las señales a

05:38.330 --> 05:41.040
un clásico de nuestra red neuronal visual.

05:41.180 --> 05:44.510
Así que ese es el que teníamos antes con capas completamente conectadas.

05:44.660 --> 05:50.730
Y ahí es donde intentará predecir los valores del cubo para cada posible acción que podamos ejecutar.

05:51.290 --> 05:56.930
Para tener en cuenta la arquitectura, primero tendremos algunas capas convolucionales y luego algunas

05:56.930 --> 06:01.270
capas completamente conectadas, y este será el cerebro de nuestra IA.

06:01.550 --> 06:07.530
Entonces, ¿qué vamos a hacer para poder dar un paso atrás en lo que estamos haciendo?

06:07.670 --> 06:11.840
Bueno, vamos a hacer esta arquitectura con las variables que queremos crear.

06:11.840 --> 06:18.890
Entonces hablando de esta arquitectura vamos a construir una CNN con tres capas convolucionales.

06:18.920 --> 06:24.530
Y luego de esa capa oculta que significa que necesitaremos tres conexiones convolucionales

06:24.530 --> 06:26.020
y dos conexiones completas.

06:26.180 --> 06:31.340
Y hablando de conexiones, eso es exactamente lo que vamos a definir que serán las variables para la

06:31.370 --> 06:35.030
clase CNN y, por lo tanto, ahora mismo voy a definir cinco variables.

06:35.150 --> 06:39.100
Tres para las conexiones convolucionales y dos conexiones políticas.

06:39.350 --> 06:40.100
Entonces, hagamos esto.

06:40.100 --> 06:42.570
Vamos a comenzar con las conexiones de convolución.

06:42.770 --> 06:47.250
Así que los llamaré convolución autodidacta.

06:47.540 --> 06:53.620
Uno va a copiar eso y basado en lo bajo.

06:54.020 --> 07:01.640
convolucional y luego esta convolucional obtendrá algunas nuevas imágenes cada una de ellas detectando una característica específica.

07:01.640 --> 07:08.450
Y luego vamos a la autoconvicción y la autoconvicción tres que son conexiones de convolución a

07:08.460 --> 07:15.860
esta primera conclusión. Aquí aplicaremos algo de convolución a las imágenes de entrada para obtener una primera

07:15.860 --> 07:21.180
capa convolucional, luego la segunda contribución aquí tomará la primera convolucional. capa

07:21.180 --> 07:25.920
como entrada y aplicando de nuevo alguna convolución creará una segunda

07:26.030 --> 07:32.840
Así que obtendremos estas nuevas imágenes en forma convolucional y luego aplicaremos esta convolución aquí para conectar

07:32.870 --> 07:39.740
estas nuevas imágenes de esta primera capa convolucional a algunas imágenes nuevas de una segunda capa de

07:39.740 --> 07:40.300
convolución.

07:40.430 --> 07:46.120
Y estas nuevas imágenes nuevamente detectarán algunas características en las imágenes del primer convolucional allí.

07:46.220 --> 07:52.100
Entonces es solo para reforzar la detección futura y luego para la aparición del segundo convolucional

07:52.100 --> 07:52.650
allí.

07:52.790 --> 07:57.000
Aplicamos el tercer convolucional aquí para obtenerlo para cada uno de ellos.

07:57.050 --> 08:01.900
Algunas imágenes más que detectan aún más características dentro de las imágenes de entrada.

08:02.050 --> 08:07.300
Y así, cuanto más hacemos esto, más aplicamos algunas circunvoluciones a las diferentes capas de imágenes.

08:07.520 --> 08:13.580
Bueno, cuanto más podamos detectar algunas características, así es como mediante la detección de características, el ojo comprenderá

08:13.580 --> 08:18.360
dónde están los monstruos, dónde tiene que disparar para matarlos y hacia dónde debería ir.

08:18.500 --> 08:21.290
También detectará las paredes de los obstáculos.

08:21.440 --> 08:28.100
Bueno, literalmente, donde tiene que ir y eso es gracias a lo que todas estas capas convolucionales detectan

08:28.130 --> 08:29.680
en las imágenes originales.

08:30.450 --> 08:34.980
Está bien así que eso es para la parte de la convolución de la CNN.

08:35.100 --> 08:42.720
Pero recuerde que después de las capas convolucionales tenemos que aplanar todos los píxeles obtenidos por las diferentes series de

08:42.720 --> 08:48.660
convoluciones que se aplicaron y aplanando todas las matrices de píxeles obtenemos este vector enorme que

08:48.810 --> 08:53.260
se convertirá en la entrada de una red neuronal artificial clásica.

08:53.490 --> 08:58.600
Y ahí es donde obtenemos nuestras letras completamente conectadas y, por lo tanto, nuestras conexiones.

08:58.710 --> 09:04.560
y allá y la capa de salida compuesta de las neuronas de salida que son los valores clave.

09:04.810 --> 09:09.330
Y ahora lo que tenemos que hacer es crear dos nuevas variables porque vamos a

09:09.330 --> 09:16.260
tener una aquí y otra en esta red neuronal artificial clásica que viene después y por lo tanto necesitamos una conexión completa de

09:16.260 --> 09:21.620
este enorme vector de Flaten a esta aquí y allí y una segunda conexión completa entre éste aquí

09:21.960 --> 09:27.090
Entonces hagamos estas dos primeras conexiones y luego definiremos todas estas conexiones.

09:27.240 --> 09:36.200
Así que pregunta por la banda sonora del código y vamos a llamarlos uno mismo y luego autodidactas a C también.

09:36.240 --> 09:41.010
Muy bien, ahora tenemos todos nuestros objetos de valor y, por supuesto, saber qué tenemos que

09:41.250 --> 09:44.300
hacer está definido con las clases del módulo del motor.

09:44.310 --> 09:49.110
básicamente crearemos la arquitectura de la red neuronal y eso es lo que haremos el próximo mañana.

09:49.190 --> 09:50.340
Entonces eso significa que

09:50.490 --> 09:51.920
Hasta entonces I.
