WEBVTT

00:00.270 --> 00:06.230
Hola y bienvenidos a este tubo y a Torro ahora tenemos que definir las cinco variables de esta

00:06.240 --> 00:09.560
función que son las tres convoluciones y las conexiones temporales.

00:09.810 --> 00:11.100
Comencemos con el primero.

00:11.250 --> 00:18.690
Convolutional uno aplica convolución a las imágenes de entrada así que esas son las imágenes originales y ahora vas

00:18.690 --> 00:22.710
a ver cómo todo será tan simple para crear esta convolución.

00:22.770 --> 00:29.070
Bueno, lo que tenemos que hacer es crear un tema de alguna clase específica y

00:29.070 --> 00:38.800
esta clase se toma de y luego las clases pasan a serlo porque estamos trabajando con imágenes en 2D y ahora, como puedes ver,

00:38.800 --> 00:40.930
tenemos que poner varias argumentos.

00:40.930 --> 00:43.140
El primero es en canales.

00:43.190 --> 00:45.910
Vamos a ponerlo en canales.

00:45.970 --> 00:49.210
El segundo es canales de salida.

00:49.330 --> 00:57.070
El tercero es el tamaño de Kerno y el resto de ellos son zancadas y grupos de dilatación.

00:57.130 --> 00:59.120
Y tenemos diferentes valores para todos estos.

00:59.260 --> 01:02.290
Así que no vamos a hacerlo, pero vamos a mantener los valores predeterminados.

01:02.470 --> 01:08.500
Pero lo importante son estos tres argumentos en canales y canales y el tamaño del kernel, así que

01:08.500 --> 01:09.740
supongo a qué corresponden.

01:09.880 --> 01:15.730
Bueno, muy simple en general corresponde a la entrada de la convolución y todos los canales corresponden

01:15.730 --> 01:17.900
a la salida de la conclusión.

01:17.920 --> 01:19.940
Asi que, Que va a ser.

01:20.110 --> 01:24.460
Bueno, muy simple, esa será la cantidad de canales en nuestras imágenes.

01:24.610 --> 01:30.460
Y en realidad vamos a trabajar con imágenes en blanco y negro porque básicamente no tenemos colores para reconocer

01:30.460 --> 01:31.360
a los monstruos.

01:31.450 --> 01:35.310
La IA es totalmente capaz de reconocer a los monstruos en blanco y negro.

01:35.440 --> 01:39.200
Así que no vemos los colores en absoluto solo los reconocemos por su forma.

01:39.250 --> 01:44.380
Por lo tanto, vamos a utilizar un canal, por lo que un canal es cuando tiene imágenes en blanco y negro

01:44.380 --> 01:46.820
y tres canales es cuando ha llamado a las imágenes.

01:46.930 --> 01:51.320
Y, por lo tanto, dado que estamos trabajando con imágenes en blanco y negro

01:51.340 --> 01:59.730
en canales, va a ser igual a uno, entonces nuestros canales para que nuestros canales vayan a ser iguales a las imágenes que desee tener en

01:59.730 --> 02:02.970
el convolucional, que es el resultado de esta constitución. uno.

02:02.970 --> 02:08.820
Y, básicamente, esto equivale a la cantidad de características que desea para el texto de las imágenes

02:09.240 --> 02:15.040
originales, ya que creará una imagen por función que queremos detectar, porque básicamente usted sabe cómo funciona.

02:15.120 --> 02:21.390
imagen de entrada y, por lo tanto, el número de imágenes de salida es la cantidad de características que queremos detectar.

02:21.390 --> 02:26.450
Aplicamos un detector de características a la imagen de entrada para detectar una característica específica en la

02:26.460 --> 02:30.110
Entonces, ahora la pregunta es cuántas características queremos detectar.

02:30.240 --> 02:38.730
Bueno, una práctica común es comenzar con 32 detectores de funciones y eso nos llevará al 32 por ciento de las imágenes en

02:38.820 --> 02:46.170
esta primera capa convolucional, por lo que la entrada es una imagen en blanco y negro una imagen real y

02:46.170 --> 02:53.010
la salida en la primera convolucional hay 32 imágenes procesadas y por procesado quiero decir, por supuesto, que

02:53.380 --> 02:59.750
la conclusión se aplicó a la imagen de entrada para obtener 32 nuevas imágenes con características detectadas.

03:00.240 --> 03:06.990
Y luego tenemos que especificar un tamaño de kernel que no es más que las dimensiones del

03:07.080 --> 03:09.450
cuadrado que atravesará la imagen original.

03:09.600 --> 03:15.350
Y en la práctica común, utilizamos para comprar dos o tres de ancho tres o cinco por cinco.

03:15.660 --> 03:22.170
Y para el primero vamos a usar un detector de cinco por cinco que es un detector de características

03:22.170 --> 03:24.580
que tendrá cinco por cinco 10 motores.

03:24.810 --> 03:29.290
Y luego reduciremos el tamaño de este núcleo para las siguientes capas convolucionales.

03:29.340 --> 03:32.320
Y hablando de eso, esto es exactamente lo que vamos a hacer ahora.

03:32.390 --> 03:40.860
Vamos a copiar esto para definir la segunda circunvolución y, por lo tanto, estoy basando eso aquí y ahora es muy divertido

03:40.890 --> 03:43.370
y muy fácil, es como un dominó.

03:43.500 --> 03:49.260
de entrada de la segunda capa convolucional es el canal de salida de la primera convolucional allí.

03:49.260 --> 03:49.810
El canal

03:49.950 --> 03:55.300
Entonces este número de salida 32 Aquí está el mismo número de entradas 32 aquí.

03:55.420 --> 04:01.290
Y eso es porque tenemos 32 imágenes en la capa convolucional de entrada de la segunda circunvolución.

04:01.440 --> 04:09.830
Y así la segunda convolución se aplica a esta segunda capa convolucional para devolver una tercera capa

04:09.830 --> 04:10.340
convolucional.

04:10.530 --> 04:13.280
Y ahora la pregunta es cuántas imágenes nuevas queremos.

04:13.410 --> 04:19.820
Bueno, lo mismo que crear 32 nuevas imágenes 32 es en realidad un número muy común en las redes

04:19.830 --> 04:23.710
neuronales convolucionales, si miras las arquitecturas encontrarás 32 en muchas de ellas.

04:24.030 --> 04:29.910
Y luego, para el tamaño del kernel, necesitamos reducir el tamaño del kernel, que son las dimensiones de nuestro detector

04:29.910 --> 04:30.610
de características.

04:30.780 --> 04:37.680
Y ahora vamos a pasar de cinco a cuatro o incluso tres y luego vamos a ir aún más pequeño.

04:37.920 --> 04:40.790
Está bien así que nuestra segunda convolución está lista.

04:40.830 --> 04:43.830
Toma como entradas 32 imágenes de proceso.

04:43.890 --> 04:51.130
Cada uno en una primera característica de la imagen de entrada original y crea 32 nuevas imágenes.

04:51.270 --> 04:54.990
Gracias a estas dimensiones reducidas del detector de características.

04:55.120 --> 04:57.250
Y ahora, empujemos esto aún más.

04:57.300 --> 05:05.450
Así que estoy copiando esto y pegándolo aquí para crear una tercera convolución para detectar algunas características.

05:05.470 --> 05:08.010
Y entonces, eso es lo mismo que los canales de entrada.

05:08.010 --> 05:13.800
Aquí está el número de imágenes de entrada a la izquierda de la conexión deconvolución y ese es el número de

05:13.800 --> 05:17.740
imágenes de precesión que fueron a la derecha de las conexiones de convolución previas.

05:17.740 --> 05:18.710
Eso es 32.

05:18.750 --> 05:20.030
Por lo tanto, lamentamos escucharlo.

05:20.030 --> 05:20.990
Eso es perfecto.

05:21.220 --> 05:25.220
Y ahora la pregunta es de nuevo cuántas imágenes nuevas queremos detectar.

05:25.310 --> 05:31.130
Vamos a tomar ahora 64 y, por lo tanto, 64 imágenes de precesión de salida.

05:31.260 --> 05:36.800
Y, por supuesto, ahora tomamos un tamaño de kernel más pequeño y vamos a tomar dos.

05:36.800 --> 05:42.660
Y esa es una arquitectura muy clásica de un convolucional y es muy eficiente tener un alto

05:42.660 --> 05:45.840
nivel de detección de características dentro de las imágenes.

05:46.200 --> 05:53.010
Está bien y ahora que tenemos nuestros tres convolucionales hay tres conexiones de convolución

05:53.010 --> 05:53.510
aquí.

05:53.640 --> 05:59.970
las 64 veces 32 veces 32 imágenes que obtuvimos de todas estas convoluciones, así que aplanamos todos los

05:59.970 --> 06:07.710
píxeles de estas imágenes y podemos un gran vector que se convertirá en la entrada de una nueva red neuronal completamente conectada.

06:08.160 --> 06:13.920
Bueno, ahora es el momento de obtener nuestras conexiones dentadas que me recuerdan que tomaremos este gran

06:14.190 --> 06:16.590
vector que obtenemos después de aplanar todas

06:16.860 --> 06:22.230
Y entonces es cuando tenemos que hacer estas conexiones entre primero este gran vector y una capa oculta y

06:22.470 --> 06:27.710
luego una segunda conexión completa entre la capa oculta y la salida que están compuestos de las neuronas

06:27.730 --> 06:28.270
de salida.

06:28.320 --> 06:31.940
Cada uno corresponde a un valor en cubo de las posibles acciones.

06:31.980 --> 06:33.960
Entonces, hagamos estas dos conexiones.

06:33.960 --> 06:35.220
Tu sabes cómo hacer eso.

06:35.220 --> 06:37.550
Eso es exactamente lo que hicimos para el auto sin conductor.

06:37.560 --> 06:38.800
Así que hagámoslo de nuevo.

06:39.000 --> 06:46.890
Bueno, primero tomamos nuestro Maggio y luego tomamos al Lynnie nuestra clase porque nuevamente la conexión que creamos es un

06:46.920 --> 06:49.060
objeto de la clase dominante.

06:49.260 --> 06:50.550
Y luego entre paréntesis.

06:50.670 --> 06:58.620
Bueno, eso es lo mismo para poner las características de entrada que es el número de ellas y luego las características de salida.

06:58.850 --> 07:03.110
Y así las características de entrada para la primera conexión completa, ¿qué va a ser?

07:03.340 --> 07:10.300
que hay en este enorme cambio de vector después de aplanar todas las imágenes de proceso después de las tres circunvoluciones.

07:10.480 --> 07:13.830
Bueno, eso va a ser igual al número de píxeles

07:13.830 --> 07:15.110
Y entonces, ¿qué significa este número?

07:15.220 --> 07:17.350
Bueno, en realidad hay un truco aquí.

07:17.380 --> 07:19.620
Este número es realmente difícil de conseguir.

07:19.660 --> 07:22.770
De hecho, necesitamos hacer una función para calcular ese número.

07:22.960 --> 07:25.570
No tenemos una variable que nos proporcione este número.

07:25.570 --> 07:29.040
Tenemos que calcularlo y, por lo tanto, lo que vamos a hacer ahora.

07:29.150 --> 07:34.780
la primera vez podrías decir "oye, no lo hago". tener este número de neuronas en el vector Flaten.

07:35.200 --> 07:40.930
Y ahora es muy importante entender la mentalidad de la programación que debemos tener y tratar de traerte

07:41.110 --> 07:45.690
la mentalidad que es lo que debes pensar ahora mismo para superar este obstáculo, porque

07:45.730 --> 07:46.650
Que debería hacer.

07:46.660 --> 07:47.600
Estoy atorado aqui.

07:47.800 --> 07:55.720
Bueno, no, en realidad porque lo que puedes hacer ahora es simplemente ingresar cualquier nombre que represente la cantidad de neuronas tan

07:55.720 --> 08:01.690
poco comunes que numeran el número de neuronas de las neuronas y luego simplemente haremos una función

08:01.690 --> 08:05.130
que retornará y este número de neuronas será variable.

08:05.180 --> 08:07.100
Esta cantidad de píxeles que estamos buscando.

08:07.330 --> 08:12.760
Entonces, podemos hacer totalmente lo que podemos poner totalmente en voz alta, por supuesto recibirá una

08:12.760 --> 08:17.090
advertencia porque todavía no existe, pero luego la crearemos con una función.

08:17.350 --> 08:21.140
Y estamos totalmente autorizados a hacerlo, incluso si la función viene después.

08:21.170 --> 08:25.970
Ese es un pensamiento de programación típico que debes tener cuando obtienes ese tipo de obstáculo.

08:26.020 --> 08:29.710
Bueno, puedes hacer una función para obtener lo que te estás perdiendo.

08:29.740 --> 08:32.640
De acuerdo y luego nuestras características y nuestro futuro.

08:32.650 --> 08:37.830
Esa es la cantidad de neuronas en una capa oculta y que esta vez depende de usted.

08:37.870 --> 08:41.230
Eso depende de la arquitectura de la nueva red que desea crear.

08:41.230 --> 08:44.230
Y entonces un buen número no sería un número pequeño.

08:44.230 --> 08:46.960
Entonces, por ejemplo, 40 neuronas podrían estar bien.

08:46.960 --> 08:48.660
Podemos intentar aumentar eso.

08:48.790 --> 08:51.280
Si el entrenamiento no es demasiado lento, puedes intentar aumentar eso.

08:51.340 --> 08:56.750
Tal vez eso mejorará las predicciones, pero comencemos con 40 quizás lo aumentemos luego.

08:57.130 --> 09:04.690
De acuerdo, eso es todo para la primera conexión completa, luego copiaremos esta pegar aquí para la segunda conexión completa que

09:04.710 --> 09:09.300
es la conexión entre la capa oculta y la capa de salida.

09:09.370 --> 09:15.720
Y así las características aquí se convierten en las características de salida de la capa anterior y eso es 40.

09:15.790 --> 09:18.020
Entonces aquí podemos poner 40.

09:18.190 --> 09:20.500
Esa es, por supuesto, la cantidad de neuronas en una capa.

09:20.860 --> 09:27.280
Y nuestro futuro va a ser igual al número de neuronas de salida que no debería haber una red neuronal.

09:27.340 --> 09:33.360
Y dado que cada neurona de salida corresponde a un nuevo valor y un Cuvee y respuesta

09:33.370 --> 09:38.440
a una acción, mientras que el número de neuronas de salida es el número

09:38.740 --> 09:47.320
de acciones y tenemos una variable para esto, que son acciones numéricas y, por lo tanto, aquí ingresamos acciones numéricas y ahí vamos felicitaciones.

09:47.390 --> 09:53.850
Encontramos la arquitectura de nuestra red neuronal. Nuestra red neuronal está compuesta por tres capas

09:53.850 --> 09:55.960
convolucionales y una capa oculta.

09:56.130 --> 10:03.020
Todo esto en una gran CNN y esta CNN detectará características en el juego para que la IA sepa dónde tiene que

10:03.020 --> 10:06.550
ir a donde tiene que ir y dónde tiene que disparar.

10:06.900 --> 10:08.240
Entonces, vamos por este paso.

10:08.340 --> 10:10.720
Ese es un primer paso muy importante.

10:10.720 --> 10:16.020
Ahora vamos a pasar al siguiente paso que es, por supuesto, obtener este número de neuronas

10:16.020 --> 10:17.010
que aún falta.

10:17.010 --> 10:21.930
Esa es la razón por la que tenemos la advertencia aquí y las neuronas del número de teléfono, pero sin preocupaciones.

10:21.960 --> 10:26.970
este enorme vector y pondremos ese número en una variable que llamará a un número de neuronas.

10:26.970 --> 10:30.210
Ahora haremos una función que devolverá el número de neuronas en

10:30.270 --> 10:32.070
Así que hagámoslo en el siguiente tutorial.

10:32.070 --> 10:33.130
Ese es nuestro siguiente paso.

10:33.180 --> 10:34.790
Y hasta entonces, disfruta de la IA.
