WEBVTT

00:00.420 --> 00:06.440
Olá e bem-vindo ao último passo do nosso processo para fazer com que o cérebro possamos uma função para deixar a esquerda.

00:06.450 --> 00:12.180
Esta é a função direta que propagará os sinais em todas as camadas da rede neural,

00:12.510 --> 00:16.180
incluindo as três camadas convolucionais e a camada totalmente conectada.

00:16.380 --> 00:21.660
E, portanto, esta função é a função direta exatamente como para o carro auto-dirigindo, exceto

00:21.780 --> 00:27.440
que neste momento, temos que propagar os sinais nas camadas convolucionais antes da camada totalmente conectada.

00:27.660 --> 00:32.610
E a boa notícia é que já fizemos isso no passo anterior com a função de contar Newnes.

00:32.640 --> 00:37.160
Então, já temos o código para propagar o sinal no país.

00:37.340 --> 00:38.940
E isso será muito rápido.

00:38.950 --> 00:43.950
Nós apenas combinaremos o que fizemos aqui e o que fizemos com o carro submarino e teremos nossa

00:43.950 --> 00:45.720
função avançada para o nosso cérebro.

00:45.780 --> 00:46.860
Então vamos fazer isso.

00:46.860 --> 00:54.660
Apresentamos uma nova função aqui a última para o cérebro e essa função é a função direta

00:55.170 --> 00:56.940
que leva um argumento.

00:57.160 --> 01:05.400
Bem, exatamente como antes de se referir aos objetos e X, que serão as imagens de entrada primeiro e então você saberá que

01:05.400 --> 01:10.280
o X será atualizado à medida que o sinal se propaga na nova rede.

01:10.650 --> 01:11.460
Tudo bem.

01:11.460 --> 01:14.350
Então, Cullen e então vamos dentro da função.

01:14.370 --> 01:20.500
Então, como acabei de dizer, já fizemos o código para propagar os sinais nas três camadas convolucionais.

01:20.580 --> 01:23.440
São exatamente essas três linhas de código.

01:23.640 --> 01:29.040
Então eu estou copiando-os e colando-os aqui e aí vamos.

01:29.040 --> 01:34.430
Nós já temos nossa propagação do sinal nas três camadas convolucionais.

01:34.520 --> 01:40.830
precisamos apenas propagar o sinal das camadas convolucionais para a camada oculta e, em seguida, eventualmente para

01:40.830 --> 01:46.680
a camada de saída que está no final da rede neural e, para isso, primeiro precisamos

01:46.680 --> 01:53.520
aplanar a terceira camada convolucional que nós Obtido aqui, lembre-se de X na primeira é a imagem de entrada.

01:53.520 --> 01:54.610
E então, agora,

01:54.720 --> 02:00.780
Então, aqui X torna-se a primeira camada convolucional, então X torna-se o segundo convolucional lá.

02:00.930 --> 02:03.840
E então, X torna-se o terceiro convolucional lá.

02:03.960 --> 02:07.730
Então, neste momento, X é a terceira camada convolucional.

02:07.860 --> 02:15.000
E agora, para adotar o achatamento lá, precisamos esparramecer esta terceira camada convolucional X e, para fazer isso, vamos fazer

02:15.070 --> 02:20.220
algo bastante parecido com o que fizemos aqui, apenas desta vez não precisamos do

02:20.220 --> 02:25.090
número de neurônios que precisamos simplesmente de achatar a canais na terceira convolução lá.

02:25.140 --> 02:28.130
Então, isso será bastante mais simples, mas muito semelhante.

02:28.410 --> 02:35.570
E para fazer isso bem, vamos tomar X de novo porque o X se tornará a camada achatadora.

02:35.890 --> 02:43.990
Estamos apenas atualizando X para x igual, então nós levamos X de novo, mas esse X é o X antigo que é a terceira camada

02:43.990 --> 02:44.480
convolucional.

02:44.550 --> 02:51.510
Então, nós tomamos o terceiro convolucional lá, então, então, nós levamos a função de exibição para a qual nos

02:51.510 --> 02:52.460
aplicamos aos argumentos.

02:52.530 --> 02:55.730
O primeiro é X esse tamanho zero.

02:56.100 --> 03:01.800
de todos os canais e a terceira camada convolucional e colocá-los um após o outro neste enorme vetor que

03:01.800 --> 03:07.320
se tornará este X aqui e este X, então, se tornará a entrada de a rede totalmente conectada.

03:07.320 --> 03:11.280
Então, novamente, nós tomamos a função de tamanho para tirar todos os pixels

03:11.460 --> 03:12.860
Mas isso não é tudo o que precisamos.

03:13.080 --> 03:14.530
E aqui vem.

03:14.650 --> 03:15.990
E menos um.

03:16.200 --> 03:19.170
Então, esse truque você pode encontrá-lo nos tutoriais de relógio de bolso.

03:19.350 --> 03:25.130
É assim que você pode aplastar um convolucional que são compostos de vários canais usando a função de tamanho.

03:25.200 --> 03:29.890
E, claro, se você quiser mais detalhes sobre como isso funciona, você pode acessar os tutoriais de relógio de bolso.

03:30.030 --> 03:31.410
Vou fornecer o link.

03:31.800 --> 03:38.250
Então, agora que conseguimos nosso achatamento lá, você sabe que este achatamento se tornará a entrada

03:38.580 --> 03:43.800
de uma rede clássica totalmente conectada com uma transmissão linear simples do sinal.

03:43.830 --> 03:49.440
E agora, não vamos usar uma função de convolução para transmitir o sinal, vamos usar

03:49.440 --> 03:54.720
uma transmissão linear com uma classe linear e, em seguida, romper a linearidade, porque quando

03:54.780 --> 03:57.670
estamos trabalhando com imagens e imagens, relacionamentos lineares.

03:57.900 --> 04:03.360
Bem, nós vamos usar uma função rectificável para poder aprender esses relacionamentos não-lineares.

04:03.510 --> 04:04.560
Então vamos fazer isso.

04:04.560 --> 04:06.160
Este é realmente o próximo passo.

04:06.210 --> 04:09.320
E agora, isso é exatamente como o que fizemos para o carro auto-dirigido.

04:09.360 --> 04:15.030
Nós tomamos o X porque queremos atualizá-lo novamente, queremos obter a camada oculta agora.

04:15.100 --> 04:20.970
E então, primeiro, o que fazemos é que tomamos nossa conexão completa SE1 porque a conexão completa.

04:20.970 --> 04:27.030
FC um é o que liga a camada achatada ao escondido e, portanto, precisamos tomar

04:27.300 --> 04:32.850
SE1 e aplicá-lo ao X que temos agora, que é a inundação lá.

04:33.000 --> 04:38.780
E nós não esquecemos o eu, é claro, porque todos são uma variável da nossa função init.

04:38.890 --> 04:45.510
Então SE1 X autodidacta e, assim, passa linearmente o sinal do lisonjeiro ao escondido.

04:45.690 --> 04:49.990
Mas agora precisamos ativar esses neurônios e, ao mesmo tempo, quebrar a lei na errância.

04:50.130 --> 04:53.480
E é exatamente isso que fazemos com a função de ativação do retificador.

04:53.490 --> 05:00.990
Então, agora, o que temos que fazer é levar nosso módulo funcional e, a partir deste módulo funcional, tomamos, naturalmente, ou

05:01.140 --> 05:03.870
função rectificável que é o verdadeiro você.

05:04.230 --> 05:08.130
E colocamos SE1 autodidacta dentro dos parênteses.

05:08.220 --> 05:14.280
Tudo bem, então o que acontece nesta linha de código é que primeiro propagamos os sinais da camada de

05:14.280 --> 05:17.210
achatamento para a camada oculta da rede totalmente conectada.

05:17.580 --> 05:23.970
E então, ativamos os neurônios desta camada oculta, quebrando o ar com esta função de

05:23.970 --> 05:29.100
ativação do retificador e nós entramos na cabeça aqui, que é perfeito.

05:29.130 --> 05:35.370
E agora temos um último passo para fazê-lo, é claro, para propagar o sinal da camada oculta para a

05:35.670 --> 05:39.680
camada de saída com os neurônios de saída final e para fazer isso.

05:39.720 --> 05:41.160
Bem, isso é muito simples.

05:41.160 --> 05:43.680
Isso é exatamente como o que fizemos no carro.

05:43.680 --> 05:51.720
Nós levamos a nossa segunda coleção completa de C2 e aplicamos isso, é claro, nos neurônios da camada oculta

05:51.990 --> 05:53.700
que é agora x.

05:53.740 --> 05:55.900
Então, aqui estão os neurônios aqui e ali.

05:56.040 --> 06:02.840
Isso tudo x e x aqui se torna, claro, os neurônios de saída da camada de saída que contém os valores do cubo.

06:03.210 --> 06:10.070
E, finalmente, simplesmente devolvemos os neurônios de saída que são x com os valores do cubo.

06:10.320 --> 06:11.240
Tão perfeito.

06:11.250 --> 06:16.950
Parabéns, acabamos de fazer um cérebro, acabamos de fazer o cérebro de nossa AI AI com os olhos e o

06:16.950 --> 06:17.740
resto das células.

06:17.790 --> 06:19.130
Então, parabéns.

06:19.140 --> 06:23.550
Agora é hora de fazer o corpo que está definindo como vamos jogar a ação.

06:23.550 --> 06:26.480
Depois de todos os sinais serem processados ​​no cérebro.

06:26.690 --> 06:28.370
Então esse é o nosso segundo grande passo.

06:28.380 --> 06:30.280
Vamos fazer isso nos próximos tutoriais.

06:30.300 --> 06:31.780
E até então AI.