WEBVTT

00:00.530 --> 00:02.950
Hola y bienvenidos a este tutorial de Python.

00:02.990 --> 00:08.520
Así que ahora el siguiente paso es hacer que las neuronas cuenten con funciones que nos den lo que queremos.

00:08.540 --> 00:14.130
Esa es la cantidad de neuronas en este enorme vector después de aplicar las convoluciones.

00:14.300 --> 00:19.640
Esa es la única información faltante que necesitamos en este momento y vamos a obtenerla con la función.

00:19.700 --> 00:23.930
Así que hagamos que esta función que vamos a llamar cuente.

00:24.280 --> 00:27.570
Y esas neuronas centrales son muy simples.

00:27.830 --> 00:32.220
Y qué es lo que esta función de contar neuronas va a tomar como argumentos.

00:32.510 --> 00:39.450
más porque este número de neuronas de salida en la capa de aplanamiento en realidad solo depende de una cosa.

00:39.450 --> 00:44.540
Bueno, va a tomar el objeto en sí, pero luego va a necesitar algo

00:44.660 --> 00:50.840
Depende de las dominaciones de la imagen de entrada original, la que va al comienzo de

00:50.840 --> 00:51.930
la red neuronal.

00:52.160 --> 00:58.370
Entonces, el único argumento que necesitamos en este momento es en realidad el momento en que se menciona el tiempo de las imágenes de entrada.

00:58.370 --> 01:03.410
Por lo tanto, démosle un nombre a este argumento que representa el diamante y la imagen de entrada.

01:03.520 --> 01:06.790
Y vamos a llamarlo imagen.

01:07.220 --> 01:07.690
Todo bien.

01:07.850 --> 01:14.720
las dimensiones reales de las imágenes de entrada que provienen de Dume van a ser de 80 por 80.

01:14.720 --> 01:16.850
Y puedo decirles ahora mismo que

01:16.850 --> 01:23.330
Vamos a reducir el tamaño de las imágenes originales a 80 por 80, y ese será el formato de

01:23.390 --> 01:26.270
las imágenes que entrarán en la red neuronal.

01:26.270 --> 01:32.300
Entonces Image them va a ser uno 80 80 y el uno corresponde al hecho de que estamos trabajando con

01:32.300 --> 01:33.750
imágenes en blanco y negro.

01:33.830 --> 01:41.040
Eso es con un solo canal, así que la imagen de ellos va a estar correlacionada con el total de ochenta y 80.

01:41.280 --> 01:41.560
Todo bien.

01:41.560 --> 01:43.590
Entonces ese es el único argumento que necesitamos.

01:43.660 --> 01:45.670
Y ahora analicemos las neuronas.

01:45.850 --> 01:47.280
Entonces, ¿cómo vas a hacer eso?

01:47.500 --> 01:51.110
Bueno, antes que nada, no tenemos ninguna imagen de entrada en este momento.

01:51.250 --> 01:54.070
No tenemos ninguna imagen de fatalidad que podamos importar.

01:54.070 --> 01:55.330
Vamos a hacer eso más tarde.

01:55.540 --> 02:01.240
Entonces, lo primero que tenemos que hacer es crear una imagen falsa, pero eso ha hecho intrones 80 sobre 80.

02:01.240 --> 02:06.160
esa imagen falsa con píxeles falsos y eso nos dará finalmente el número que queremos

02:06.160 --> 02:12.280
porque ese número solo depende de las dimensiones y no de los píxeles que están dentro de las imágenes.

02:12.280 --> 02:13.320
Vamos a crear

02:13.330 --> 02:15.640
Entonces esto solo crea una imagen falsa para comenzar.

02:15.730 --> 02:18.520
Y luego calcularemos la cantidad de neuronas que queremos.

02:18.520 --> 02:23.860
Entonces, el truco para crear una imagen falsa es que lo llamaremos x.

02:23.890 --> 02:30.700
En primer lugar, luego usaríamos la antorcha de ese Rand, porque sabes que vamos a poner algunos píxeles

02:30.700 --> 02:37.200
aleatorios en estas imágenes, ya que estamos usando estas funciones aleatorias de torche, que es la función rand.

02:37.250 --> 02:42.740
Luego adentro vamos a ingresar como puedes ver las maldiciones de las imágenes.

02:42.850 --> 02:44.400
Ese es uno 80 80.

02:44.560 --> 02:50.500
Pero ya que vamos a poner esta imagen en la red neuronal y, como recordarán, la red neuronal solo

02:50.500 --> 02:55.170
puede aceptar lotes de estados de entrada que están aquí lotes de imágenes de entrada.

02:55.370 --> 03:00.600
Vamos a crear esos diamantes falsos en los que podemos hacer esta función de ejecución directamente.

03:00.670 --> 03:05.720
De hecho, solo comenzamos con el que corresponderá al lote y luego podemos

03:05.730 --> 03:11.070
simplemente subirlo a la 188 correspondiente a las dominaciones de la imagen de entrada.

03:11.110 --> 03:16.980
Y como usted entendió estas nominaciones están contenidas en esta imagen, el argumento que

03:16.980 --> 03:19.330
representa esa tabla 1 80 80.

03:19.420 --> 03:23.290
Entonces solo necesitamos agregarles imágenes.

03:23.620 --> 03:29.410
Pero para pasar los elementos de la tabla porque ya lo sabe, Image them es un doble

03:29.410 --> 03:31.940
como una lista de argumentos de una función.

03:32.020 --> 03:39.460
Necesitamos agregar aquí antes de la imagen que hay antes de que la tienda de Apple la tienda permita pasar los elementos

03:39.550 --> 03:44.100
de la imagen a Apple como una lista de argumentos para la función.

03:44.170 --> 03:49.600
Y como pueden ver, eso es exactamente lo que se especifica aquí con la tienda y el diamante.

03:49.930 --> 03:56.640
De acuerdo, creará una imagen de píxeles falsos que no tendrá nada que ver con las imágenes.

03:56.800 --> 04:01.720
el número final de neuronas y ahora lo último que tenemos

04:01.720 --> 04:11.080
que recordar es convertir este vector de entrada en una variable de antorcha porque esto va a ir a la red neuronal.

04:11.380 --> 04:13.060
Pero nuevamente podremos obtener

04:13.060 --> 04:13.380
Todo bien.

04:13.390 --> 04:20.650
Entonces, esto ahora representa una imagen de entrada de píxeles aleatorios que se acaba de convertir en un viable y que ahora

04:20.650 --> 04:22.440
irá a la red neuronal.

04:22.570 --> 04:28.330
Y más específicamente, las capas convolucionales de la red neuronal porque, dado que solo necesitamos

04:28.330 --> 04:34.100
el número de neuronas después de aplicar las convoluciones, simplemente ascenderemos a las convoluciones 3.

04:34.210 --> 04:36.440
Así que hasta la tercera capa convolucional.

04:36.580 --> 04:39.630
Y no entraremos en las dos conexiones completas aquí.

04:39.850 --> 04:45.490
Y eso es porque la cantidad de neuronas que queremos es entre convolución 3 y f. c 1.

04:45.520 --> 04:52.120
Muy bien, ahora que tenemos una imagen de entrada con las menciones correctas Bueno, es hora de propagar esta imagen

04:52.180 --> 04:58.330
en la red neuronal para alcanzar la capa de aplanamiento, luego vamos a obtener las neuronas en la

04:58.330 --> 05:03.850
capa aplanada y obtendremos el La información que queremos es la cantidad de neuronas en esta

05:03.850 --> 05:04.750
capa de aplanamiento.

05:04.990 --> 05:08.950
Entonces, ahora tenemos que hacer es exactamente lo que hacemos en una función de reenvío.

05:08.950 --> 05:14.560
Necesitamos propagar las señales a la red neuronal, pero solo en las capas convolucionales hasta que lleguemos

05:14.560 --> 05:16.120
a la capa de inundación.

05:16.330 --> 05:17.360
Entonces, hagamos esto.

05:17.360 --> 05:25.660
Vamos a actualizar x ahora x es la imagen de entrada y con la segunda X aquí X será la

05:25.660 --> 05:27.050
primera capa convolucional.

05:27.310 --> 05:32.930
Y ahora lo que tenemos que hacer es el primer paso del proceso de tres pasos, aplicar la deconvolución a las

05:32.950 --> 05:33.790
imágenes de entrada.

05:33.850 --> 05:40.960
Luego, en el segundo paso aplicamos la poda de mezcla a las intrincadas imágenes e inserciones que activamos las

05:40.960 --> 05:48.160
neuronas en estas imágenes intrincadas y puñadas y las x se convertirán en las primeras convolucionales que están compuestas

05:48.160 --> 05:50.590
de todas estas piscinas enredadas Energis.

05:51.010 --> 05:56.840
Así que vamos a hacer este primer paso aplicar la primera convolución de convolución a las imágenes de entrada.

05:57.040 --> 06:07.540
Entonces, lo que hacemos es tomar nuestra convolución uno mismo que convo Lucian uno que vamos aplicamos a nuestras imágenes de

06:07.550 --> 06:11.360
entrada que hasta ahora están representados por x.

06:11.500 --> 06:14.290
Entonces, eso es lo primero que primero se hace ahora.

06:14.320 --> 06:22.630
Segundo paso vamos a aplicar spooling a nuestras intrincadas imágenes devueltas por convolución cuando X y dos clímax tirando

06:22.640 --> 06:26.880
Bueno, vamos a tomar una función del módulo funcional.

06:26.920 --> 06:34.610
Así que tomamos el atajo que eso y luego vamos a usar la función Max pool para D.

06:34.810 --> 06:42.340
una X en el paréntesis de la máxima atracción porque jugamos el próximo tirón en las intrincadas imágenes.

06:42.360 --> 06:45.220
Ese es el que colocamos la autoconvolución

06:45.750 --> 06:53.140
Pero esta próxima función toma argumentos adicionales que son primero el tamaño del kernel.

06:53.190 --> 06:59.190
Entonces, de nuevo, ese es el tamaño de la ventana que se desliza a través de sus imágenes y que tomará el

06:59.190 --> 07:00.710
máximo de píxeles en cada diapositiva.

07:00.830 --> 07:06.750
Entonces eso aún detectará las características porque las características están asociadas a un alto valor del píxel

07:06.840 --> 07:07.750
en las matrices.

07:07.890 --> 07:09.580
Como dices las conferencias de intuición.

07:09.780 --> 07:14.020
Entonces, esta primera necesidad humana documentada de ingresar es este tamaño de kernel.

07:14.100 --> 07:15.560
Y vamos a tomar tres.

07:15.660 --> 07:17.650
Esa es una opción común para el tamaño del kernel.

07:17.940 --> 07:25.200
Y luego tenemos que poner los pasos que sabe por la cantidad de píxeles que se va a deslizar en las imágenes.

07:25.200 --> 07:27.560
Y vamos a tomar un paso de dos.

07:27.610 --> 07:29.400
De nuevo, esa es una elección común.

07:29.820 --> 07:30.670
Entonces ahí vamos

07:30.690 --> 07:32.530
Ahora el segundo paso está hecho.

07:32.620 --> 07:38.910
pasamos al tercer paso, que es activar todas las neuronas en este grupo e imágenes intrincadas.

07:38.910 --> 07:39.580
Y ahora

07:39.610 --> 07:46.090
Y esta primera capa de convolución y para hacer esto de nuevo vamos a aplicar una función a todo esto.

07:46.170 --> 07:51.960
Así que aquí y tomo de nuevo porque vamos a tomar otra función que, como habrás

07:52.050 --> 07:55.170
adivinado, será una función de activación, pero cuál.

07:55.230 --> 08:01.410
Como de costumbre, va a ser la función de activación rectificada y tal vez recuerdes el nombre que

08:01.620 --> 08:02.330
realmente es.

08:02.790 --> 08:03.410
Aquí vamos.

08:03.450 --> 08:04.290
Ese es.

08:04.290 --> 08:12.540
Y entonces aplicamos realmente a nuestras imágenes enrevesadas agrupadas que es todo esto.

08:12.540 --> 08:12.940
Todo bien.

08:12.990 --> 08:14.270
Y eso es.

08:14.370 --> 08:15.320
Tres pasos hechos

08:15.330 --> 08:16.370
Eso fue muy rápido.

08:16.500 --> 08:23.460
Así que recuerda la forma en que tenemos que mirar esto, primero aplicamos la convolución a nuestras imágenes

08:23.460 --> 08:28.830
de entrada y aplicamos Max tirando de nuestras intrincadas imágenes obtenidas con una convolución.

08:28.950 --> 08:35.730
convolucional en la que se produjo un clímax y en la que las neuronas ahora están activadas.

08:35.730 --> 08:43.960
Y luego activamos las neuronas en toda esta capa convolucional de la piscina con la función de activación del rectificador tan

08:44.050 --> 08:46.200
perfecta que obtenemos nuestra primera capa

08:46.260 --> 08:51.640
Y básicamente, lo que hace es propagar las señales desde la primera capa convolucional a

08:51.640 --> 08:52.500
la siguiente.

08:52.630 --> 08:56.580
Y hablando de la siguiente, eso es exactamente de lo que nos vamos a ocupar en este momento.

08:56.570 --> 09:01.660
Vamos a hacer lo mismo que acabamos de hacer en la primera convolución allí a la

09:01.660 --> 09:08.170
segunda capa convolucional para volver a propagar las señales a la red neuronal mediante la activación de las neuronas de

09:08.170 --> 09:09.660
la segunda capa convolucional.

09:09.850 --> 09:12.910
Pero antes de hacer esto, necesitamos obtener esta capa convolucional.

09:13.120 --> 09:18.330
Y entonces vamos a aplicar la convolución a X que ahora es la primera capa convolucional.

09:18.460 --> 09:24.070
Bueno, vamos a aplicar la convolución a 2 x para obtener la segunda capa convolucional, después de lo cual

09:24.070 --> 09:25.120
Max la extraerá.

09:25.240 --> 09:27.860
Y finalmente activando Sirat.

09:27.970 --> 09:29.070
Entonces, hagamos esto.

09:29.170 --> 09:35.350
De hecho, es muy fácil copiar eso y pegarlo a continuación.

09:35.350 --> 09:39.240
Ahora, por supuesto, necesitamos reemplazar la convolución uno por convolución también.

09:39.520 --> 09:40.460
Y ahí vamos.

09:40.480 --> 09:43.650
Eso está realmente listo, ve muy fácil.

09:43.900 --> 09:50.200
Y ahora con esta línea propagamos las señales desde el segundo convolucional hasta el siguiente

09:50.260 --> 09:52.580
que será el tercero convolucional allí.

09:52.720 --> 09:57.220
Y para obtener esta tercera voluntad convolucional tendrá que aplicar eso de nuevo.

09:57.220 --> 10:04.630
Así que estoy copiando esta pegada a continuación y reemplazando la convolución también por convolución 3 y eso está hecho,

10:04.870 --> 10:06.340
¿no es tan práctico?

10:06.340 --> 10:11.490
Propagamos las señales en las tres letras convolucionales en una linterna.

10:11.500 --> 10:13.100
Gracias a esta impresionante estructura.

10:14.020 --> 10:15.340
Muy bien, perfecto.

10:15.340 --> 10:21.250
Ahora tenemos nuestras señales propagadas hasta la tercera capa convolucional y después.

10:21.360 --> 10:24.780
Y hablar de eso nos lleva a lo que estamos buscando.

10:24.820 --> 10:28.510
Lo que nos interesa es el aplanamiento allí.

10:28.510 --> 10:33.620
Muy bien, así que ahora que tenemos nuestro tercer convolucional ahí esa es la última X aquí.

10:33.790 --> 10:36.120
Es hora de conseguir nuestro aplanamiento.

10:36.490 --> 10:37.990
Y eso es exactamente lo que vamos a hacer.

10:37.990 --> 10:44.200
Ahora vamos a aplanar todos los píxeles de esta tercera capa convolucional, es decir, vamos a tomar

10:44.290 --> 10:48.430
todos los píxeles de todos los canales de la tercera capa convolucional.

10:48.640 --> 10:51.920
Vamos a ponerlos uno tras otro en un gran vector.

10:52.150 --> 10:56.920
Y, por supuesto, este enorme vector no será más que la capa de aplanamiento y

10:56.920 --> 11:02.000
al mismo tiempo utilizaremos un truco para obtener el número de neuronas en este aplanamiento allí.

11:02.070 --> 11:03.790
Eso es lo que estamos buscando.

11:03.790 --> 11:09.370
de neuronas que nos falta y, por lo tanto, devolvamos directamente lo que queremos y, en este

11:09.370 --> 11:15.130
retorno, aplanaremos la tercera capa convolucional y obtendremos el mismo número de neuronas en esta capa de aplanamiento.

11:15.130 --> 11:16.330
Esa es la cantidad

11:16.630 --> 11:20.150
Entonces vamos a tomar X. que es nuestro tercer convolucional allí.

11:20.320 --> 11:25.150
Vamos a tomar todos los canales del tercer convolucional allí y vamos a utilizar una

11:25.150 --> 11:32.160
función que es la función de tamaño para aplanar todos los píxeles de todos estos canales en un mismo vector enorme.

11:32.230 --> 11:35.930
Y así, el truco lo puedes encontrar en la pena ver el trabajo.

11:36.130 --> 11:42.400
Bueno, primero tomamos los datos de X porque X es una estructura especial, sabes que es una antorcha Voivode, así

11:42.400 --> 11:44.250
que tiene una estructura bastante compleja.

11:44.320 --> 11:51.920
Pero primero necesitamos acceder a ella con datos aquí, entonces necesitamos ver qué hay dentro de ella.

11:52.090 --> 11:57.700
Entonces usamos esta función de vista y ahora necesitamos acceder a lo que estamos buscando

11:57.700 --> 12:01.980
y eso es incluso con los argumentos 1 y menos 1.

12:02.230 --> 12:04.390
Tienes que entender lo que hay dentro de la estructura.

12:04.510 --> 12:10.060
Pero puedes entender que así es como conseguiremos este número de neuronas y luego,

12:10.150 --> 12:15.560
para finalizar, debemos agregar el tamaño entre paréntesis y dentro de las entradas 1.

12:15.880 --> 12:21.610
Básicamente, lo que hacemos aquí es lo que hacemos: tomamos todos los píxeles de todos los canales y

12:21.610 --> 12:27.180
los colocamos uno tras otro en este vector enorme que será la entrada de la red totalmente conectada.

12:27.190 --> 12:29.250
Eso es básicamente lo que hace el tamaño.

12:29.410 --> 12:34.060
Y con esto podemos obtener este número de nuevos que estamos buscando.

12:34.060 --> 12:36.460
Está bien, así que ahora obtenemos lo que queremos.

12:36.490 --> 12:44.350
Y así finalmente podemos reemplazar el número de neuronas aquí por lo que devuelve esta función cuando se

12:44.530 --> 12:47.400
aplica al formato de las imágenes.

12:47.440 --> 12:50.140
Eso es uno por 80 por 80.

12:50.170 --> 13:00.040
Entonces, lo que tenemos que hacer ahora es reemplazar el número de neuronas por la función de conteo de

13:00.250 --> 13:09.040
neuronas que aplicamos al formato de las imágenes, que será el total de 80 y 80.

13:09.460 --> 13:10.400
Y ahí vamos.

13:10.510 --> 13:17.140
Y, por supuesto, no nos olvidamos de nosotros mismos porque Count neuron es realmente un método de la prueba CNN.

13:17.170 --> 13:18.490
Entonces, necesitamos agregar el.

13:18.700 --> 13:21.190
Y ahora la advertencia debería desaparecer.

13:21.190 --> 13:22.540
Y ahí vamos.

13:22.540 --> 13:23.890
Ahora todo está bien.

13:23.980 --> 13:29.930
Obtenemos la arquitectura de la red neuronal sin que falte nada y tenemos esta función de contravinculación en

13:30.140 --> 13:35.290
caso de que sepa que desea probar algunas otras arquitecturas y no desea contar la cantidad

13:35.290 --> 13:36.210
de neuronas manualmente.

13:36.340 --> 13:39.940
Simplemente usa esta función para reproducirla en el formato de sus imágenes.

13:40.180 --> 13:42.130
Y esto te llevará directamente a lo que quieres.

13:42.130 --> 13:45.810
Esa es la cantidad de neuronas en la capa de inundación sin tener que hacer nada.

13:45.820 --> 13:49.450
Y donde sea que la arquitectura sea crítica.

13:49.480 --> 13:57.040
Y ahora hemos terminado con el primer gran paso importante de este cerebro que estamos haciendo y tenemos un

13:57.040 --> 13:57.720
último paso.

13:57.790 --> 14:02.500
Esa es una última función para hacer, que será la función de reenvío principal.

14:02.590 --> 14:07.730
desde los ojos hasta la capa de salida que está después de la segunda conexión.

14:07.730 --> 14:12.160
Así que vamos a propagar las señales desde el principio del cerebro

14:12.460 --> 14:15.850
Así que haremos eso en los próximos dos años y hasta entonces nuestra IA.
