WEBVTT

00:00.360 --> 00:06.030
Olá e bem-vindo à primeira parte desta implementação AI, uma parte construindo a IA.

00:06.120 --> 00:12.570
E, como você pode ver, eu já adicionei dimensão na estrutura desse recuo com estas três seções que compõem

00:12.660 --> 00:16.620
a Parte 1, que mostram claramente como vamos construir essa AI.

00:16.620 --> 00:18.750
Primeiro, vamos fazer o cérebro.

00:18.840 --> 00:23.760
Não há nada além da rede neural, então vamos criar o corpo que definirá

00:23.760 --> 00:25.400
como as ações serão jogadas.

00:25.590 --> 00:31.620
E então, uma vez que temos o cérebro e o corpo, vamos montá-los para fazer o AI que

00:31.620 --> 00:33.840
estará na última seção desta primeira parte.

00:33.840 --> 00:37.890
Então agora você já pode ter uma boa visão da estrutura dessa implementação.

00:37.890 --> 00:42.760
Primeiro, fazemos o cérebro, então fazemos o corpo e depois montamos os dois para fazer a AI.

00:43.050 --> 00:48.520
E então, isso é tudo o que vamos começar com a primeira seção sobre fazer o cérebro.

00:48.810 --> 00:51.330
E isso vai nos levar para tutoriais.

00:51.360 --> 00:54.810
Você pode imaginar que fazer um cérebro não é como fazer um bolo.

00:54.900 --> 00:57.100
Portanto, isso exigirá mais de um tutorial.

00:57.270 --> 01:03.690
como de costume, vamos representar esse cérebro com uma classe porque precisaremos de várias funções

01:03.690 --> 01:10.200
e para ter uma estrutura de várias funções que serão organizadas em algum tipo de instruções.

01:10.200 --> 01:11.160
E, claro,

01:11.310 --> 01:16.010
Bem, é claro, precisamos de uma aula e é Berkeley porque uma vez que fizemos essa aula.

01:16.080 --> 01:22.080
Bem, seremos capazes de criar tantos cérebros como queremos apenas criando alguns objetos dessa classe.

01:22.080 --> 01:28.050
Então, novamente, as aulas em Python e, em geral, as linguagens de programação orientadas a objetos são muito práticas

01:28.200 --> 01:33.510
porque você faz um modelo de algo que deseja criar e, em seguida, você pode criar tantos

01:33.510 --> 01:37.820
objetos quanto desejar e terão todos os recursos que você definir na classe.

01:38.010 --> 01:40.470
E, para o nosso cérebro, as características serão, naturalmente.

01:40.500 --> 01:45.930
de entrada para os neurônios de saída que serão, naturalmente, a função Ford que fará.

01:45.930 --> 01:51.780
Bem, antes de tudo, a arquitetura da rede neural que eu lembro será da CNN e, claro,

01:51.780 --> 01:55.520
duas funções diferentes, como, por exemplo, transmitir os sinais dos neurônios

01:55.920 --> 01:58.940
Então, vamos fazer isso, vamos começar a fazer o cérebro.

01:58.950 --> 02:00.600
Isso vai ser bastante emocionante.

02:00.650 --> 02:02.380
É uma das minhas partes favoritas.

02:02.520 --> 02:04.860
E, portanto, vamos entrar diretamente nisso.

02:04.890 --> 02:10.880
Então, vamos começar apresentando a aula, e nós vamos chamar essa classe.

02:10.950 --> 02:18.570
de cérebro, mas vamos ser mais diretos e vamos chamá-lo de CNN porque, na verdade, o cérebro é uma rede CNN.

02:18.570 --> 02:20.570
Bem, eu hesitei em chamar

02:20.580 --> 02:22.510
Rede neural convolutiva.

02:22.530 --> 02:27.440
Então, como você vê, você pode ligar para o cérebro se quiser, mas pelo menos agora sabemos o que estamos construindo.

02:28.710 --> 02:35.040
E a CNN Quanto à rede do carro auto-dirigido vai herdar do fim de Mudgal.

02:35.220 --> 02:42.870
Então, lembre-se do final do módulo é o que colocamos aqui e queremos poder usar todas as ferramentas

02:42.870 --> 02:49.050
deste e um módulo e, portanto, queremos usar essa técnica em programação orientada a

02:49.050 --> 02:55.870
objetos que é herança e que nos permite saber bem, use todas as ferramentas de uma

02:55.900 --> 02:59.970
classe pai e esta mesma classe será nesse módulo.

02:59.970 --> 03:00.830
Aqui vamos nós.

03:00.930 --> 03:05.510
E agora podemos usar todas as ferramentas e objetos no final desse módulo.

03:05.510 --> 03:12.100
Tudo bem, agora que temos nossa herança, podemos entrar na classe para fazer nossa primeira função.

03:12.150 --> 03:18.360
E, como você provavelmente adivinhou, a primeira função é a função final que irá definir todas as variáveis

03:18.720 --> 03:20.330
​​dos futuros objetos do cérebro.

03:20.370 --> 03:23.440
Você conhece o futuro e os objetos que serão criados.

03:23.700 --> 03:24.890
Tudo bem, então vamos fazer isso.

03:24.900 --> 03:29.800
Def, então, dois sublinhados nessas pontuações novamente.

03:29.910 --> 03:31.910
E agora precisamos colocar algumas variáveis.

03:32.100 --> 03:37.460
Então, antes de tudo, eu iria ser eu mesmo, é claro, para se referir ao objeto.

03:37.490 --> 03:42.380
Agora, acho que você está muito confortável com isso, então vamos adicionar outra variável

03:42.380 --> 03:45.310
que será o número de ações no ambiente Dumah.

03:45.500 --> 03:48.900
Então, vamos chamar esse número de ações.

03:49.010 --> 03:50.380
Número de ações.

03:50.570 --> 03:54.390
E, na verdade, essa variável não é obrigatória para a função.

03:54.500 --> 03:59.360
É só isso se você quer testar a idéia que vamos construir em outros ambientes.

03:59.540 --> 04:06.100
Bem, isso será muito prático, porque vamos importar esse número de ações horríveis da doom

04:06.120 --> 04:12.290
e Varman wrappers com dois discretos e ao fazê-lo, você saberá inserir o nome

04:12.510 --> 04:13.980
do ambiente, o zero.

04:14.180 --> 04:21.050
E então, se você quer que você conheça experimente com isso em outros ambientes e jogue outros jogos, você não

04:21.050 --> 04:26.300
terá nada a fazer porque esse número de ações receberá diretamente o número de ações

04:26.300 --> 04:27.470
no ambiente Dumor.

04:27.470 --> 04:28.650
Você estará jogando com.

04:29.110 --> 04:32.710
OK, então é para os dois argumentos desta função.

04:32.780 --> 04:36.500
Então agora podemos entrar e agora lembre-se do que temos que fazer.

04:36.530 --> 04:41.560
A primeira coisa que temos a fazer é ativar a herança com a superfunção.

04:41.570 --> 04:43.840
Então é exatamente assim para o carro auto-dirigido.

04:43.970 --> 04:50.940
Nós levamos a superfunção, então, dentro, começamos por inserir a classe que irá definir a rede

04:51.470 --> 04:53.330
neural e a CNN.

04:53.690 --> 04:56.950
Então, temos que inserir-nos para se referir ao objeto.

04:57.190 --> 05:05.230
Mas lembre-se que não é tudo o que precisamos adicionar aqui no DOT e, em seguida, a função init com alguns parênteses.

05:05.270 --> 05:07.880
E, ao fazê-lo, ativamos a herança.

05:07.950 --> 05:11.470
E agora podemos usar todas as ferramentas do final e do módulo.

05:11.510 --> 05:17.070
Tudo bem, agora acho que é hora de construir a arquitetura da rede neural.

05:17.270 --> 05:23.330
E, assim como você se lembra, vamos construir uma rede nervosa convoluta da CNN simplesmente

05:23.330 --> 05:30.290
porque desta vez a IA terá olhos e os olhos do olho serão as camadas convolutivas desta

05:30.290 --> 05:31.220
rede neural convolutiva.

05:31.520 --> 05:38.240
E, depois de ai ai visualizar as imagens com as camadas convolucionais, passará os sinais para

05:38.330 --> 05:41.040
um clássico a nossa rede neural visual.

05:41.180 --> 05:44.510
Então, esse é o que tínhamos antes com camadas totalmente conectadas.

05:44.660 --> 05:50.730
E é aí que tentará prever os valores do cubo para cada ação possível que possamos tocar.

05:51.290 --> 05:56.930
Então, você tem a arquitetura em mente, primeiro vamos ter algumas camadas convolutivas e, em seguida,

05:56.930 --> 06:01.270
algumas camadas totalmente conectadas e esse será o cérebro da nossa AI.

06:01.550 --> 06:07.530
Então, o que vamos fazer para poder dar um passo atrás no que estamos fazendo.

06:07.670 --> 06:11.840
Bem, vamos fazer essa arquitetura com as variáveis ​​que queremos criar.

06:11.840 --> 06:18.890
Então, falando sobre essa arquitetura, vamos construir uma CNN com três camadas convolutivas.

06:18.920 --> 06:24.530
E, depois disso, uma camada oculta que significa que precisamos de três conexões convolutivas

06:24.530 --> 06:26.020
e duas conexões completas.

06:26.180 --> 06:31.340
E falando de conexões, é exatamente o que estamos prestes a definir, que serão as variáveis

06:31.370 --> 06:35.030
​​para a classe CNN e, portanto, agora vou definir cinco variáveis.

06:35.150 --> 06:39.100
Três para as conexões convolutivas e duas conexões políticas.

06:39.350 --> 06:40.100
Então vamos fazer isso.

06:40.100 --> 06:42.570
Vamos começar com as conexões de convolução.

06:42.770 --> 06:47.250
Então eu vou chamar convolução autodidata.

06:47.540 --> 06:53.620
Um vai copiar isso e com base no baixo.

06:54.020 --> 07:01.640
e, em seguida, essa convolução irá obter algumas imagens novas, cada uma delas detectando uma característica específica.

07:01.640 --> 07:08.450
E então, vamos a autoconfiança e a autoconvenção três que são conexões de convolução para

07:08.460 --> 07:15.860
esta primeira conclusão, aqui aplicamos alguma convolução às imagens de entrada para obter uma primeira camada

07:15.860 --> 07:21.180
convolucional, então a segunda contribuição para aqui levará a primeira convolução camada

07:21.180 --> 07:25.920
como entrada e, aplicando novamente alguma convolução, criará uma segunda convolução

07:26.030 --> 07:32.840
Então, vamos ter essas novas imagens em uma convolução lá, então vamos aplicar esta convolução aqui para

07:32.870 --> 07:39.740
conectar essas novas imagens desta primeira camada convolucional a algumas novas imagens de uma segunda camada de

07:39.740 --> 07:40.300
convolução.

07:40.430 --> 07:46.120
E estas novas imagens novamente irá detectar alguns recursos nas imagens do primeiro convolucional lá.

07:46.220 --> 07:52.100
Então é apenas para reforçar a futura detecção e depois para o surgimento do segundo convolucional

07:52.100 --> 07:52.650
lá.

07:52.790 --> 07:57.000
Nós aplicamos o terceiro convolucionário aqui para buscá-lo para cada um deles.

07:57.050 --> 08:01.900
Algumas imagens mais que detectam ainda mais recursos dentro das imagens de entrada.

08:02.050 --> 08:07.300
E assim, quanto mais nós fazemos isso, mais aplicamos algumas convoluções para as diferentes camadas de imagens.

08:07.520 --> 08:13.580
Bem, mais podemos detectar alguns recursos e é assim, ao detectar recursos, o olho irá entender onde

08:13.580 --> 08:18.360
os monstros estão onde deve disparar para matá-los e para onde deve ir.

08:18.500 --> 08:21.290
Também detectará as paredes dos obstáculos.

08:21.440 --> 08:28.100
Bem, literalmente, onde tem que ir e isso é graças ao que todas essas camadas convolutivas

08:28.130 --> 08:29.680
detectam nas imagens originais.

08:30.450 --> 08:34.980
Tudo bem, então é para a parte de convolução da CNN.

08:35.100 --> 08:42.720
Mas, então, lembre-se, após as camadas convolucionárias, de aplainar todos os pixels obtidos pelas diferentes séries de convoluções que

08:42.720 --> 08:48.660
foram aplicadas e ao achatar todas as matrizes de pixels, obtemos esse enorme vetor que

08:48.810 --> 08:53.260
se tornará a entrada de uma rede neural artificial clássica.

08:53.490 --> 08:58.600
E é aí que recebemos nossas letras totalmente conectadas e, portanto, nossas conexões.

08:58.710 --> 09:04.560
este aqui e ali e a camada de saída composta pelos neurônios de saída que são os valores-chave.

09:04.810 --> 09:09.330
E agora, o que temos a fazer é criar duas novas variáveis ​​porque

09:09.330 --> 09:16.260
vamos ter uma aqui e aí nesta rede neural artificial clássica que vem a seguir e, portanto, precisamos de uma

09:16.260 --> 09:21.620
conexão completa desse enorme vetor Flaten para este aqui e e uma segunda conexão completa entre

09:21.960 --> 09:27.090
Então, vamos fazer essas duas primeiras conexões e então vamos definir todas essas conexões.

09:27.240 --> 09:36.200
Então, pergunte pela trilha sonora no código, vamos chamar a si mesmos de um e mesmo autodôndice C também.

09:36.240 --> 09:41.010
Tudo bem, então agora temos todos os nossos objetos de valor e saber o que temos que fazer

09:41.250 --> 09:44.300
é, naturalmente, definido então com as classes do módulo do motor.

09:44.310 --> 09:49.110
basicamente criaremos a arquitetura da rede neural e é o que faremos no próximo amanhã.

09:49.190 --> 09:50.340
Então, isso significa que

09:50.490 --> 09:51.920
Até então, eu.