WEBVTT

00:00.270 --> 00:02.250
Olá e seja bem vindo à loja.

00:02.430 --> 00:05.810
Estou super animado porque estamos prestes a fazer o A-3 ver o cérebro.

00:05.810 --> 00:07.430
Esse é o cérebro da nossa AI.

00:07.590 --> 00:10.800
E falando sobre cérebro, eu gostaria de destacar algo.

00:10.870 --> 00:15.750
Lembre-se no primeiro módulo que fizemos um cérebro simples com apenas camadas totalmente conectadas.

00:15.840 --> 00:22.260
Então, no segundo módulo para Dhoom, fizemos um cérebro que não só tinha camadas totalmente conectadas, mas

00:22.350 --> 00:29.070
também olhos porque adicionamos as camadas convolucionárias que deram olhos aos olhos porque podiam observar as imagens e

00:29.070 --> 00:31.550
entender o que está acontecendo dentro.

00:31.830 --> 00:37.590
E agora vamos dizer que, mesmo em um nível alto, porque vamos fazer um cérebro que

00:37.590 --> 00:41.310
não só terá olhos e conecte completamente camadas, mas também memória.

00:41.430 --> 00:46.710
Como, como eu disse no tutorial anterior, vamos adicionar um registro sobre esse trabalho

00:46.710 --> 00:53.490
dentro deste grande cérebro e isso dará uma longa memória ao nosso cérebro para que ele possa entender

00:53.580 --> 00:57.010
as relações temporais nas propriedades temporais das imagens de entrada.

00:57.120 --> 01:02.400
Então, nós vamos e até um cérebro ainda mais poderoso, posso dizer-lhe que o Dymo sobre

01:02.640 --> 01:09.930
Intiman agora é realmente muito poderoso e podemos ver como construir o AI e fazer cada vez mais profundo e o aprendizado

01:10.260 --> 01:14.820
do Forsman é cada vez mais próximo de como funciona o cérebro humano.

01:14.820 --> 01:19.560
Você sabe que começamos com as relações básicas do cérebro com as conexões lineares.

01:19.560 --> 01:22.230
Então adicionamos olhos e adicionamos a memória.

01:22.230 --> 01:24.900
Quem sabe o que vamos adicionar nos futuros modelos.

01:24.990 --> 01:30.780
Você sabe que em 2018 talvez eles adicionem algo que fará com que o cérebro pareça mais parecido com um

01:30.780 --> 01:31.330
cérebro humano.

01:31.680 --> 01:37.590
Mas já com olhos e memória de lasers totalmente conectados já temos um cérebro realmente bom

01:37.590 --> 01:38.280
e funcional.

01:38.790 --> 01:39.690
Então, vamos fazê-lo.

01:39.750 --> 01:41.140
Vamos fazer esse cérebro.

01:41.310 --> 01:46.470
Então, como de costume, vamos fazer uma aula para isso porque vai ter muitas propriedades

01:46.470 --> 01:48.780
com as convoluções e a ciência.

01:48.870 --> 01:53.770
Então, vamos fazer com que funcione para inicializar tudo isso, crie todas essas conexões.

01:54.090 --> 01:59.220
E então, claro, teremos a função Ford que, naturalmente, propagará o sinal dentro

01:59.220 --> 02:02.580
do cérebro para que possamos obter eventualmente o resultado.

02:02.580 --> 02:03.200
Tudo bem.

02:03.240 --> 02:04.020
Você está pronto.

02:04.140 --> 02:05.400
Vamos fazer isso.

02:05.400 --> 02:13.470
Então, aula que apresentamos na aula, que chamamos de ator, porque, claro, estou falando de cérebros aqui.

02:13.470 --> 02:13.700
 

02:13.710 --> 02:19.440
Mas não esqueçamos que estamos fazendo com o modelo que se baseia no princípio crítico ativo com

02:19.650 --> 02:24.810
separadamente o ator e o crítico assim fará uma das conexões quase completas para o

02:24.810 --> 02:27.770
ator e uma conexão significativa para o crítico.

02:27.810 --> 02:30.880
Você verá o quão bem nós faremos, isso será bastante simples.

02:30.900 --> 02:39.060
esta aula de ator vai herdar desde o fim e que Maggio para que possamos usar todas as ferramentas de Pitre.

02:39.060 --> 02:40.780
Então crítico ativo e

02:40.860 --> 02:44.130
Então, vamos fazer isso para herdar desde o fim nesse módulo.

02:44.190 --> 02:53.000
Bem, precisamos levar primeiro a biblioteca da tocha, então, então e então e aquilo e Mudgal.

02:53.090 --> 02:54.100
Tudo bem.

02:54.110 --> 02:55.600
Assim herdamos disso.

02:56.990 --> 02:57.240
Tudo bem.

02:57.260 --> 03:01.630
Então, vamos com nossa primeira função, que será, naturalmente, em sua função.

03:01.640 --> 03:10.400
a chamamos de entradas não e a fase de ações que é basicamente o espaço que contém todas as ações.

03:10.850 --> 03:17.970
Então, começamos com o seu duplo sublinhado, então esta função vai assumir como argumento auto com

03:18.050 --> 03:25.820
o objeto, então a forma de entrada que é a dominação de nossas imagens de entrada e nós

03:26.000 --> 03:31.340
Também sabemos que, a partir deste espaço de ação, podemos obter uma série de ações que são uma série

03:31.700 --> 03:33.870
de ações possíveis que realmente irão em breve.

03:33.870 --> 03:38.290
Então, é por isso que também precisamos disso para os argumentos.

03:38.290 --> 03:39.390
Isso é tudo o que precisamos.

03:39.650 --> 03:45.450
E então vamos dentro da função e vamos criar todas as variáveis ​​próprias do nosso cérebro.

03:45.830 --> 03:51.740
ferramentas do final de Maggio, temos que usar a superfunção dessa maneira dentro da qual inserimos.

03:52.040 --> 03:59.450
Mas antes de fazer isso, lembre-se do que devemos fazer para ativar de alguma forma a herança em que podemos usar

03:59.450 --> 04:00.180
todas as

04:00.440 --> 04:10.740
Crítico de ator que é a nossa classe e, em seguida, venha a si próprio com o objeto. Tudo

04:10.740 --> 04:14.840
bem, então, vamos novamente com a função.

04:14.940 --> 04:15.560
Aqui vamos nós.

04:15.600 --> 04:20.100
Isso nos dá todas as ferramentas que todos precisamos da tocha para construir nosso cérebro.

04:20.400 --> 04:21.940
Tudo bem então.

04:22.170 --> 04:24.690
Bem, é hora de fazer os olhos dos olhos.

04:24.780 --> 04:26.210
São as convoluções.

04:26.460 --> 04:31.770
Então, vamos fazer isso muito rapidamente porque já explicamos isso em detalhes por desgraça.

04:31.800 --> 04:34.210
Porque eu lembro do dia em que eu tinha gelo.

04:34.260 --> 04:39.240
Então, é exatamente o mesmo, vamos fazer algumas conclusões e usaremos uma arquitetura muito simples

04:39.510 --> 04:45.240
com 32 detectores de recursos de tamanho três por três passos de dois e um preenchimento de um.

04:45.450 --> 04:50.460
Então, essa é uma arquitetura muito clássica, mas isso realmente será suficiente para você saber, certifique-se de que

04:50.690 --> 04:53.010
eu entendo o que está acontecendo no intervalo.

04:53.010 --> 04:54.090
ESTÁ BEM.

04:54.480 --> 04:56.750
Tudo bem, então vamos fazer essas convoluções.

04:56.790 --> 05:03.900
Então, começamos com o eu porque as convoluções serão variáveis ​​dos objetos tão auto que podemos chamá-lo

05:03.900 --> 05:09.210
de vir, e haverá quatro convoluções de modo que esse pode ser um.

05:09.540 --> 05:11.040
E nós vamos lá.

05:11.040 --> 05:18.900
Nós levamos o ponto N e Maggio e então nós levamos o cone para a aula porque, na verdade, o convenant

05:18.930 --> 05:20.670
será um objeto de desgosto.

05:21.540 --> 05:25.870
E então dentro primeiro colocamos a forma de entrada das imagens.

05:25.920 --> 05:32.780
Então, exatamente o que temos aqui para que possamos copiar isso e inseri-lo como a primeira entrada.

05:33.090 --> 05:38.600
Então, o segundo argumento é o número de detectores de recursos também são o número de kernels.

05:38.640 --> 05:45.060
Então, vamos ter 32, como acabamos de dizer escolha clássica, então precisamos escolher o tamanho do kernel

05:45.060 --> 05:50.130
que é o número de células que serão deslocadas sobre a imagem de entrada.

05:50.190 --> 05:55.170
E então lembre-se de que podemos tomar três ou quatro ou cinco que estão nas

05:55.290 --> 05:58.460
escolhas e vamos escolher três e então vamos escolher.

05:58.550 --> 06:01.100
Tentei.

06:01.340 --> 06:11.350
E um preenchimento de um que vamos para a primeira convolução que vai da imagem de entrada para a

06:11.350 --> 06:16.210
primeira camada convolucional é composto de 32 imagens complicadas.

06:16.360 --> 06:18.850
Então, agora estamos prontos para fazer a segunda convolução.

06:18.850 --> 06:27.290
Então, na verdade, vai ser quase o mesmo, então eu estou copiando essa linha e baseando isso abaixo,

06:27.310 --> 06:33.490
colado abaixo e colando uma última vez porque vamos ter quatro convoluções com

06:33.490 --> 06:42.640
quase nada para mudar, então podemos substituir. Aqui vem um vem por um a três e vem um por quatro.

06:42.670 --> 06:45.160
Serão as nossas quatro convoluções.

06:45.160 --> 06:49.330
E agora, é claro, precisamos mudar algumas coisas aqui, mas não muito porque vamos

06:49.370 --> 06:52.280
acompanhar duas para cada um e um padrão de um.

06:52.420 --> 06:58.620
Todos terão 32 detectores de recursos que possuem 32 imagens enroladas de resultados.

06:58.780 --> 07:04.040
Mas, então, lembre-se que isso corresponde à parte esquerda da convolução.

07:04.180 --> 07:09.610
Então, na verdade, isso corresponde ao que estava na parte certa da conclusão anterior, você sabe que é

07:09.610 --> 07:10.370
como um dominó.

07:10.390 --> 07:11.440
É muito fácil.

07:11.560 --> 07:22.390
E, portanto, aqui temos que colocar 32 e aqui é onde vamos ver muito facilmente 32 e 32.

07:22.390 --> 07:27.790
Tudo bem, para resumir, começamos com nossas imagens de entrada que não possuem nenhum.

07:27.810 --> 07:35.350
32 imagens enroladas, cada uma detectando uma característica específica, a partir dessas 32 imagens complicadas, aplicamos a

07:35.800 --> 07:43.120
segunda convolução para obter 32 novas imagens enroladas e as mesmas dessas 32 novas imagens complicadas.

07:43.420 --> 07:46.510
Simon Jones foi a primeira convolução, recebemos

07:46.510 --> 07:52.430
Nós aplicamos a terceira convolução para obter novamente 32 novas imagens complicadas e, eventualmente,

07:52.450 --> 07:57.470
das três imagens enroladas, aplicamos a quarta convolução para obter recursos.

07:57.490 --> 07:57.910
Tudo bem.

07:57.910 --> 08:03.700
E isso será suficiente com isso ou eu vou ter uma supervisão que levará a bola muito bem.

08:03.700 --> 08:07.250
Tudo bem, então é para a convolução. Então é isso mesmo para os olhos.

08:07.420 --> 08:09.490
E agora vamos cuidar da memória.

08:09.640 --> 08:15.520
Esta nova característica deste cérebro que estamos implementando em oposição antes com não só

08:15.680 --> 08:23.140
terá uma supervisão, mas também terá uma memória super memória longa porque vamos ver Memória de curto prazo

08:23.170 --> 08:29.230
longo, que é esse tipo de registro ou um neural rede que dá ao seu

08:29.230 --> 08:36.580
modelo algum tipo de memória longa para que possa aprender algumas longas relações temporais do passado, assim dizendo

08:36.580 --> 08:43.180
que vamos criar novas variáveis ​​desde o tempo com a pessoa e essa nova variável, vamos

08:43.180 --> 08:47.260
chamá-la simplesmente porque isso corresponderá à rede LACMA dentro do cérebro.

08:47.290 --> 08:55.240
Então, SVM e antes de escrever o código para o LCN, vamos nos certificar de que entendamos o que essa parte do cérebro

08:55.240 --> 08:56.270
da LACMA fará.

08:56.530 --> 09:03.980
Então, como entendemos, este LCN é usado para aprender as propriedades temporais das imagens de entrada de entrada.

09:04.090 --> 09:09.730
Então, por exemplo, se a bola atingir uma LACMA irá codificar o saldo.

09:09.730 --> 09:11.410
Então é a primeira coisa a entender.

09:11.410 --> 09:15.070
Isso codificará o que está acontecendo no jogo.

09:15.070 --> 09:20.080
Então, a próxima coisa importante para entender quando implementamos esse ISTM é que

09:20.170 --> 09:26.680
precisamos escolher em ordem das dependências temporais e aqui, uma vez que vamos alimentar nossa rede neural

09:26.680 --> 09:33.740
com uma seqüência de quatro imagens, então isso significa que podemos já Aprenda algumas dependências temporais de ordem,

09:33.740 --> 09:40.310
pois algumas dependências temporais são o que acontece às 1:20 depende do que acontece no momento T.

09:40.360 --> 09:45.500
T menos 1 T menos 2 e T menos 3 para que possamos definitivamente fazer isso.

09:45.730 --> 09:51.040
Mas a boa notícia é que vamos usar a análise YEM e, portanto,

09:51.160 --> 09:54.560
poderemos aprender algumas relações temporais ainda mais complexas.

09:54.650 --> 10:00.430
Por exemplo, podemos aprender algumas propriedades simples, onde o que acontece às 1:20 dependerá do que acontece

10:00.430 --> 10:01.370
no momento T.

10:01.370 --> 10:05.510
T menos 20 minutos para fazer menos três para T menos.

10:05.940 --> 10:13.360
E essa é a parte longa da longa memória de curto prazo com este ensaio e podemos aprender

10:13.360 --> 10:15.490
algumas relações temporais muito complexas.

10:15.490 --> 10:18.080
Tudo bem, então vamos adicionar o nosso LCN.

10:18.160 --> 10:25.030
Então, para fazer isso, vamos usar o N no módulo e então vamos adicionar a classe como T. N. célula que criará isso como um

10:25.600 --> 10:31.960
objeto que representará o DST e parte da nova rede, porque agora o que também é

10:31.960 --> 10:38.570
importante entender é que estamos fazendo um CR e então você conhece o registro convolucional de

10:38.590 --> 10:45.520
uma nova rede e a parte arland vem depois da CNN parte e, portanto, agora, o que

10:45.610 --> 10:51.350
precisamos inserir nesta célula LACMA é primeiro o tamanho da saída após a convolução.

10:51.400 --> 10:56.060
Então, isso é 32 vezes três vezes três.

10:56.230 --> 11:02.670
Então, este 32 vezes três vezes três é realmente a saída após as quatro convoluções aqui.

11:02.830 --> 11:07.600
Mas isso se torna a entrada do RNA, o LSD e esse trabalho.

11:07.870 --> 11:13.710
E agora, por que o resultado das quatro circunvoluções metade do tamanho três duas vezes três vezes três.

11:13.870 --> 11:16.030
Bem, não se preocupe, não é tão direto.

11:16.060 --> 11:22.140
Na verdade, não é uma fórmula simples, mas existe uma fórmula para calcular esse número de neurônios de saída.

11:22.210 --> 11:26.490
Depois de aplainar as imagens agrupadas e enroladas da deconvolução.

11:26.710 --> 11:32.050
Mas se reunimos os termos desta grande fórmula. Bem, recebemos 32 vezes três vezes três.

11:32.200 --> 11:36.060
Eu não queria passar muito tempo sobre isso porque temos muito a fazer mais.

11:36.190 --> 11:39.470
E, além disso, já fizemos uma função para calcular esse número.

11:39.520 --> 11:43.710
Lembre-se de que era para destruição quando fazemos isso contar com neurônios.

11:43.870 --> 11:45.750
Então você pode reutilizá-lo se quiser.

11:45.760 --> 11:51.610
Você não está convencido, mas é exatamente o que obtemos depois de reunir os termos desta grande fórmula,

11:51.610 --> 11:53.490
como calcular o número de saídas.

11:53.530 --> 11:59.380
Então, é para o primeiro argumento e então o segundo argumento será o número de neurônios

11:59.380 --> 12:00.370
de saída do.

12:00.610 --> 12:05.220
E iremos para 256 OK.

12:05.220 --> 12:12.180
e o crítico porque você sabemos que vamos fazer duas novas redes separadas para o ator e outra para

12:12.540 --> 12:19.260
o crítico, mas serão a mesma codificação das imagens e dos relacionamentos temporais para essas duas redes neurais.

12:19.620 --> 12:25.470
E então, o que isso significa agora, isso significa que agora temos um vetor que codifica

12:25.470 --> 12:31.410
cada evento do jogo ou, em outras palavras, temos um estado codificado e agora é que

12:31.410 --> 12:33.990
podemos fazer a separação entre o ator

12:33.990 --> 12:37.740
Então, esta é a parte comum que fazemos para essas duas novas redes.

12:37.740 --> 12:43.650
Este será o mesmo começo para as duas novas redes, mas agora as coisas vão mudar para o

12:43.650 --> 12:49.710
ator e o riacho, porque vamos fazer uma na conexão completa para o ator e uma conexão diferente

12:49.710 --> 12:52.200
da quase completa para o craic .

12:52.230 --> 12:56.320
Então vamos dar uma pausa rápida e vamos fazer isso no próximo pouco.

12:56.400 --> 12:57.860
Até então, desfrute da AI.