WEBVTT

00:00.420 --> 00:07.170
Olá e bem-vindo novamente para Mudgal para fazê-los, agora vamos nos preparar para iniciar a implementação de

00:07.170 --> 00:07.910
nossa AI.

00:08.040 --> 00:13.610
E, como de costume, a primeira coisa que precisamos fazer é definir o pai certo como diretório de trabalho.

00:13.600 --> 00:17.360
Então, vamos fazer isso agora para que possamos avançar para o que é mais interessante.

00:17.610 --> 00:24.240
Então, como de costume, eu começo na minha área de trabalho, então eu vou para a minha inteligência artificial que a pasta, então,

00:24.240 --> 00:25.450
o módulo agora faz.

00:25.650 --> 00:29.240
E nós vamos ao que temos que definir como um diretório de trabalho.

00:29.520 --> 00:34.890
Então, vamos fazer isso agora, clicamos nesses dois, mas aqui, então, reinicie o kernel e depois sim.

00:35.100 --> 00:35.990
E aqui vamos nós.

00:36.090 --> 00:39.070
Agora temos a pasta certa como um diretório de trabalho.

00:39.480 --> 00:45.450
Então agora você pode ver que temos quatro fúcsia bem, na verdade, três mil uma pasta nesta pasta do

00:45.450 --> 00:46.250
diretório de trabalho.

00:46.260 --> 00:47.640
Então vamos começar com o primeiro.

00:47.640 --> 00:50.080
O primeiro é de qualquer forma.

00:50.260 --> 00:55.910
Esse é, naturalmente, o arquivo que conterá nossa inteligência artificial e isso não é mais do que esse

00:55.920 --> 00:56.710
arquivo aqui.

00:56.910 --> 01:04.710
Esse é o AIW em que vou implementar tudo o que está relacionado com a construção de uma IA e, especialmente, a criação de

01:04.710 --> 01:07.130
uma AI AI com o convolucional profundo.

01:07.130 --> 01:08.740
Q aprendendo mais.

01:09.080 --> 01:12.200
Então, basicamente, é aí que teremos a grande aventura.

01:12.240 --> 01:17.210
Então temos algum outro Feltz, temos o segundo andar, que é a experiência que jogamos dessa forma.

01:17.460 --> 01:23.970
E, desta vez, eu coloco a experiência para jogar separadamente, porque já a implementamos e agora

01:23.970 --> 01:25.870
queremos nos concentrar nos novos.

01:25.980 --> 01:32.370
inteligência artificial, porque não só queremos criar uma AI AI, mas queremos construir qualquer AI para vencer o destino.

01:32.370 --> 01:36.620
E confie em mim, temos muitas coisas novas a fazer com essa nova

01:36.690 --> 01:42.540
Então, você pode imaginar que isso exigirá algum código bastante avançado, portanto, não se preocupe.

01:42.540 --> 01:46.850
Nós temos um código grande esperando por nós e você aprenderá muitos truques novos.

01:46.860 --> 01:53.450
É por isso que essa experiência replay o truque que você já conhece e que eu lembro melhora muito o treinamento.

01:53.640 --> 01:59.550
Bem, vamos colocá-lo separadamente nesta experiência que jogamos que encontrei para que possamos concentrar-nos agora em todas

01:59.550 --> 02:02.950
as novas técnicas e truques de conceitos que nos esperam.

02:03.060 --> 02:06.890
Tudo bem e depois temos o pré-processamento de imagem que encontrei.

02:06.930 --> 02:12.510
ter olhos e isso é porque os estados de entrada não são mais codificados por um vetor.

02:12.510 --> 02:18.890
Então, esse é outro arquivo python que cuidará de pré-processamento ou imagens, porque você conhece esse tempo ou eu vou

02:18.960 --> 02:21.560
Mas desta vez os estados de entrada são as imagens.

02:21.570 --> 02:27.960
Assim, a primeira camada da grande rede neural que será feita será os olhos e serão as

02:27.960 --> 02:34.830
camadas convolutivas da nova rede convolutiva para garantir que essas imagens possam ser aceitas como entradas da rede

02:34.830 --> 02:35.710
neural convolutiva.

02:35.850 --> 02:42.270
Bem, precisamos preprocessá-los e, portanto, este fight cuidará de pré-processamento dessas imagens para que elas

02:42.270 --> 02:44.220
possam entrar na rede neural.

02:44.220 --> 02:48.850
E então eu separei essa válvula porque isso não está diretamente relacionado à AI.

02:48.960 --> 02:55.350
E novamente, queremos manter o máximo do nosso cérebro em nossa memória e nosso foco em tudo o que

02:55.350 --> 02:56.530
está relacionado à AI.

02:56.700 --> 03:02.430
Então, estamos colocando isso separadamente para que possamos processar até apenas uma luz de flash e

03:02.430 --> 03:03.860
economizar energia pelo resto.

03:03.910 --> 03:07.690
Você pode dar uma olhada se quiser e você também tem os núcleos profundos.

03:07.740 --> 03:10.490
Bem, você pode dar uma olhada nos tutoriais práticos.

03:10.560 --> 03:12.690
Falamos sobre processamento de imagens.

03:12.840 --> 03:15.410
Bem, aqui novamente, realmente queremos nos concentrar nos olhos.

03:15.420 --> 03:19.770
Confie em mim, temos muito a fazer e, eventualmente, a última pasta.

03:19.890 --> 03:21.660
Bem, essa é a pasta de vídeos.

03:21.720 --> 03:24.650
Então, agora, esta pasta está vazia, como você pode ver.

03:24.780 --> 03:31.190
Mas quando executamos o código, alguns vídeos da apelação serão adicionados a esta pasta.

03:31.290 --> 03:36.770
Então, isso será muito emocionante porque veremos em alguns vídeos o quão bem a AI está fazendo.

03:36.870 --> 03:42.070
Então, literalmente, veremos a AI matando os monstros e tentando correr para o objetivo.

03:42.220 --> 03:44.410
Você vai ver que isso será bastante emocionante.

03:44.580 --> 03:50.790
bem, o olho ficará melhor e melhor e, eventualmente, será conseguem matar alguns monstros que não são mortos.

03:50.790 --> 03:56.940
Então, é claro, os primeiros vídeos serão muito ruins, porque o olho ainda não será treinado e,

03:56.940 --> 04:02.330
assim, será morto muito rápido, mas então você verá que, como o treinamento está progredindo

04:02.430 --> 04:06.660
E espero que possamos conseguir chegar ao alcance.

04:06.660 --> 04:10.720
Tudo bem, então vamos voltar para a nossa AFL, que é apenas uma.

04:10.860 --> 04:16.710
E como você pode ver, eu já cuidei de importar todas as bibliotecas e pacotes centrais que precisamos

04:17.040 --> 04:17.870
para tocá-los.

04:18.060 --> 04:23.160
Então vamos dar uma rápida olhada neles, um a um, claro que não temos, porque vamos trabalhar

04:23.160 --> 04:23.920
com arrays.

04:24.090 --> 04:25.740
Isso é inevitável.

04:25.740 --> 04:29.500
Então conversamos, claro, porque estamos implementando o AI com uma tocha.

04:29.580 --> 04:35.220
Então temos a tocha que e um módulo que contém todas as ferramentas para implementar uma rede neural.

04:35.220 --> 04:40.740
Assim, por exemplo, o módulo conterá as camadas convolutivas que serão parte de nossa

04:40.740 --> 04:41.790
rede neural futura.

04:41.790 --> 04:49.110
Então, temos isso e depois aquele pacote funcional que tem um atalho e que contém todas as funções que são

04:49.110 --> 04:50.840
usadas em uma rede neural.

04:50.970 --> 04:57.480
funções de pool para as redes neurais da empresa e todas essas funções estão contidas em funcional.

04:57.790 --> 05:04.010
Assim, normalmente, as funções de ativação estarão usando algumas funções de ativação de retificação, mas também algumas

05:04.240 --> 05:10.990
Então, temos até ele o que, claro, é para otimizador, acho que vamos usar um otimizador de complementos e

05:10.990 --> 05:18.250
este otimizador está contido em cima dele e, em seguida, o melhor do melhor por torche a classe de variável

05:18.250 --> 05:24.400
do módulo de autógrafos e isso é tudo o poder de tudo, porque isso é o que

05:24.400 --> 05:29.860
contém os gráficos dinâmicos permitindo realizar cálculos muito rápidos dos gradientes, mesmo o gradiente de

05:29.860 --> 05:30.820
funções de composição.

05:30.850 --> 05:32.870
Então, definitivamente vamos usá-lo.

05:32.890 --> 05:34.400
Quanto ao soldado no carro.

05:34.510 --> 05:37.890
Mas confie em mim para Dume, vamos precisar disso muito mal.

05:38.260 --> 05:45.080
Eu acho que é tudo para as bibliotecas essenciais, então precisamos importar alguns pacotes relacionados ao agente

05:45.090 --> 05:46.680
aberto e à destruição.

05:46.810 --> 05:53.560
Então, é claro, importamos Jim, então importamos algum módulo de wrappers da biblioteca de genes e um

05:53.560 --> 05:55.340
desses wrappers é Kyp wrapper.

05:55.380 --> 05:59.170
Então é basicamente para importar todas as ferramentas e ambientes de Jim.

05:59.230 --> 06:04.390
E, finalmente, temos esse pacote que precisamos importar e que está diretamente relacionado a fazer.

06:04.510 --> 06:11.470
invólucro de doom que basicamente contém o ambiente da destruição e mais especificamente as ações que podem ser jogadas.

06:11.470 --> 06:15.330
E esse é o espaço real e dois discretos do

06:15.340 --> 06:19.620
O número de ações para este jogo específico que vamos jogar.

06:19.750 --> 06:25.450
E lembro que há seis seções movem para a esquerda movem para a direita vire à esquerda vire à direita, mova-se

06:25.450 --> 06:27.300
para a frente e atira o ataque.

06:27.440 --> 06:30.780
Tudo bem, então é basicamente o que você precisa importar para o destino.

06:30.820 --> 06:36.950
E, finalmente, é claro que precisamos importar nossa experiência de dois arquivos internos.

06:36.970 --> 06:38.430
Nós tocamos uma experiência pura de Whyfor.

06:38.440 --> 06:45.220
pré-processamento de imagem para pré-processar as imagens que não são senão as imagens da tela.

06:45.220 --> 06:45.950
Reproduzimos um

06:46.060 --> 06:52.810
Ao jogar o jogo e essas imagens serão pré-processadas, convertidas em não pagadores remodeladas para um determinado

06:52.810 --> 06:58.680
formato e depois irão para o novo que foi convolutivo em uma que estava bem.

06:58.680 --> 07:07.710
Então, acho que agora estávamos prontos para iniciar a grande implementação desta IA e agora é muito importante para mim dizer-lhe que isso

07:07.710 --> 07:13.890
me leva ao ponto muito importante deste Munjal é que, desde que você sabe, eu disse

07:13.890 --> 07:17.370
que temos um grande implementação esperando por nós.

07:17.490 --> 07:21.720
Bem, para não se perder em tudo isso, precisamos de uma boa estrutura.

07:21.930 --> 07:24.950
E então eu já destaquei a estrutura.

07:25.170 --> 07:28.020
Vamos implementar isso em duas partes.

07:28.020 --> 07:30.920
A primeira parte será sobre a construção da AI.

07:31.110 --> 07:35.260
Então é aí que vamos fazer o cérebro do ai ai no cérebro.

07:35.280 --> 07:38.260
Como você entendeu, não é senão a rede neural.

07:38.370 --> 07:45.390
Você conhece essa grande CNN composta de algumas camadas convolutivas e, em seguida, algumas camadas totalmente conectadas para

07:45.390 --> 07:46.710
prever as saídas.

07:46.710 --> 07:50.430
Ainda existem os valores-chave e então vamos fazer o corpo da AI.

07:50.550 --> 07:53.270
E essa é a nova representação que estou trazendo para você.

07:53.400 --> 07:55.490
E isso é novamente para não se perder.

07:55.620 --> 08:01.260
Você verá que quanto mais avançarmos com o código, mais veremos a estrutura e tudo

08:01.260 --> 08:02.590
terá sentido no final.

08:02.880 --> 08:06.480
E para ter certeza de que faz sentido precisamos de uma representação da AI.

08:06.690 --> 08:12.840
E, basicamente, esta primeira parte da construção da AI será composta por três seções.

08:12.840 --> 08:17.370
A primeira seção será sobre fazer o cérebro que é a rede neural.

08:17.430 --> 08:20.200
A segunda seção será sobre como fazer o corpo.

08:20.400 --> 08:25.200
E eu chamo isso de corpo, porque essa é a parte que vai dizer à AI como jogar a ação.

08:25.200 --> 08:30.590
Então você sabe primeiro que você tem o cérebro que detecta as imagens e prediz os valores de q.

08:30.660 --> 08:36.480
Mas, então, você precisa especificar como a AI deve desempenhar a ação e que ela faz com o seu valor

08:36.480 --> 08:37.790
como o corpo humano faria.

08:38.040 --> 08:44.010
Então, o corpo será a parte em que vamos especificar o método de ação.

08:44.010 --> 08:50.280
Então, por exemplo, com nosso carro de auto-condução, o cérebro era uma rede neural que fizemos e o corpo era como

08:50.280 --> 08:51.500
a ação era tocada.

08:51.570 --> 08:53.540
Isso é com o próximo método de Saft.

08:53.700 --> 08:58.290
o mesmo que vamos criar um cérebro e vamos fazer um corpo que jogará a ação.

08:58.290 --> 08:59.080
E aqui é

08:59.190 --> 09:00.320
Vou deixar você descobrir.

09:00.520 --> 09:06.180
Mas o ponto-chave em tudo isso é que teremos um código muito estruturado para que não só você

09:06.180 --> 09:11.610
possa dar um passo atrás e realmente entender o que está acontecendo, mas também você poderá usá-lo

09:11.850 --> 09:15.360
como uma estrutura sempre que quiser construir o AI para outros fins.

09:15.360 --> 09:15.970
Tudo bem.

09:15.990 --> 09:17.540
E depois de construir o.

09:17.640 --> 09:24.810
a segunda parte, que será sobre a implementação do convolucional aqui e ali novamente, terão diferentes seções.

09:24.810 --> 09:26.820
Na primeira parte, passaremos para

09:26.910 --> 09:29.850
E um deles será, naturalmente, para treinar a AI.

09:30.240 --> 09:32.560
Então eu não posso esperar para mergulhar nisso agora.

09:32.580 --> 09:38.950
Vamos começar com um obviamente e vamos começar fazendo o cérebro de nossa IA.

09:39.330 --> 09:41.580
Então eu não posso esperar até então.

09:41.680 --> 09:42.090
AI.