WEBVTT

00:00.420 --> 00:04.730
Olá e bem-vindo ao último passo desta primeira parte do edifício.

00:04.860 --> 00:10.500
Agora, o único fato que temos de deixar é fazer com que a Ford funcione, que

00:10.500 --> 00:16.650
irá propagar o sinal desde o início, quando o cérebro está conseguindo a imagem até o final quando

00:16.650 --> 00:22.260
coloco a ação para que possamos fazer isso Toda a função e esse será o nosso

00:22.260 --> 00:26.710
último passo antes de avançarmos para formar nossa IA com kulang convolucional profundo.

00:26.890 --> 00:28.080
Então vamos fazer isso.

00:28.080 --> 00:34.470
Vamos chamar a chamada de função que realmente é semelhante à função de init que é uma

00:34.470 --> 00:38.760
função existente, mas desta vez a utilizamos para chamar algumas outras funções.

00:38.790 --> 00:43.170
Os que fizemos antes, porque você sabe que vamos usar a função direta do

00:43.290 --> 00:45.490
cérebro e a função portuária do corpo.

00:45.630 --> 00:50.270
E então estamos usando essa função agora para basicamente chamar essas funções.

00:50.550 --> 00:53.160
Então, a chamada vai levar dois argumentos.

00:53.160 --> 00:54.330
O primeiro é o eu.

00:54.330 --> 01:00.220
É claro que o objeto e o segundo argumento que, de acordo com você, será o que será.

01:00.360 --> 01:02.910
Bem, estamos fazendo toda a propagação desta vez.

01:02.910 --> 01:08.460
naturalmente, as imagens de entrada porque, claro, esse é o ponto de partida quando a AI está jogando o jogo.

01:08.460 --> 01:10.860
Então, o que queremos tomar como entrada é,

01:10.860 --> 01:16.080
Primeiro visualiza as imagens do jogo, depois propaga os sinais no cérebro e depois

01:16.080 --> 01:17.180
toca a ação.

01:17.190 --> 01:20.130
Portanto, o segundo argumento será insumos.

01:20.610 --> 01:24.740
E agora estamos prontos para fazer toda essa propagação.

01:24.810 --> 01:26.220
Então vamos fazer isso novamente.

01:26.220 --> 01:31.900
Então, o primeiro passo onde é o primeiro passo é receber as imagens de entrada do jogo.

01:32.190 --> 01:38.010
que temos que formatá-los em uma estrutura especial e a estrutura é, naturalmente, uma estrutura de tocha.

01:38.010 --> 01:42.840
E uma vez que essas imagens vão entrar na rede neural. Bem, você pode imaginar

01:42.840 --> 01:48.420
Então, a primeira coisa que acontecerá é que vamos converter essas imagens em uma matriz de árbitro,

01:48.420 --> 01:55.320
então a converteremos em um tensor da tocha e, finalmente, vamos colocar o tensor da tocha dentro de uma variável de

01:55.500 --> 01:58.260
tocha que conterá o tensor e um gradiente.

01:58.350 --> 02:03.780
Isso é para os nossos gráficos dinâmicos para calcular de forma muito eficiente os gradientes mais tarde Kattie rápido,

02:03.780 --> 02:04.460
no sentido.

02:04.620 --> 02:06.200
Então esse é o nosso primeiro passo.

02:06.270 --> 02:12.130
imagens, eles poderão entrar na rede neural e então é onde vamos fazer toda a propagação dos sinais.

02:12.360 --> 02:16.320
E então, uma vez que possamos obter o formato certo de nossas

02:16.380 --> 02:20.340
Então, vamos fazer isso primeiro, convertendo a imagem no formato certo.

02:20.430 --> 02:23.050
Então, nossas imagens são tão para insumos.

02:23.220 --> 02:26.780
Agora vamos criar uma nova variável que eu estou chamando de entrada.

02:26.820 --> 02:30.470
Então, essa é a entrada real da rede neural e essa entrada.

02:30.510 --> 02:31.760
Onde é que vai ser.

02:31.920 --> 02:34.490
Bem, primeiro, precisamos tomar nossos insumos.

02:34.530 --> 02:36.650
Estas são as nossas imagens originais.

02:36.870 --> 02:42.190
Então, como dissemos, queremos converter essas imagens em arrays Nampa.

02:42.330 --> 02:49.260
Então, para fazer isso, podemos simplesmente não tomar nenhum, pelo que tenha um atalho e, em seguida, a matriz de funções.

02:49.500 --> 02:52.850
Então colocamos entre parênteses da matriz de funções.

02:52.890 --> 02:53.340
Aqui vamos nós.

02:53.340 --> 02:55.940
Agora é convertido em algo e por matrizes.

02:56.190 --> 03:02.790
Mas então, uma vez que as células dos arrays numpad conterão os pixels, é realmente mais seguro

03:02.790 --> 03:04.230
especificar o tipo flutuante.

03:04.310 --> 03:11.040
É melhor ter certeza de que temos alguns carros alegóricos agora para garantir que possamos usar esse flutuador.

03:11.090 --> 03:12.690
Desculpe por ouvir.

03:12.720 --> 03:15.390
Tudo bem agora, ainda temos um árbitro.

03:15.540 --> 03:17.330
Mas com o tablet.

03:17.720 --> 03:24.150
Tudo bem e essa também é outra razão, é que os tensores são por definição arrays de um único tipo.

03:24.270 --> 03:28.060
E então escolhemos o tipo único para ser um flutuador flutuante 32.

03:28.060 --> 03:28.350
Tudo bem.

03:28.350 --> 03:34.440
Agora que temos o nosso não-bio, o próximo passo é converter isso em um sensor de

03:34.440 --> 03:37.990
tartaruga e, para isso, podemos usar, por exemplo, uma tocha.

03:38.070 --> 03:45.380
E depois da função não-piloto de sublinhado que o converterá em um sensor de tocha.

03:45.420 --> 03:46.200
Aqui vamos nós.

03:46.210 --> 03:52.320
E agora o último passo é colocar esses sensores de tocha em uma variável de tocha contendo o tensor

03:52.320 --> 03:53.230
e o acordo.

03:53.400 --> 04:02.010
E você sabe como fazê-lo, é claro, nós levamos a nossa classe de variáveis ​​porque, na verdade, tudo que está dentro dessa

04:02.010 --> 04:05.530
variável é realmente a entrada da classe de variáveis.

04:05.760 --> 04:11.400
Mas eu queria mostrar isso para você dessa maneira porque você sabe que começamos com as nossas imagens de

04:11.400 --> 04:15.890
entrada, então as convertemos em matrizes numeradas, depois para tensores de tocha e depois amanhã.

04:16.170 --> 04:17.220
E agora estamos bons.

04:17.220 --> 04:23.370
Eles são autorizados a entrar na rede neural que é primeiro os olhos do olho e, em seguida, as

04:23.370 --> 04:25.770
camadas totalmente conectadas para levar a previsões.

04:26.220 --> 04:30.340
Então, falando sobre os olhos dos olhos, é exatamente o que vamos fazer agora.

04:30.480 --> 04:37.280
Nós vamos propagar essas imagens permitidas agora nos olhos dos olhos que são através das

04:37.290 --> 04:38.720
três camadas convolucionais.

04:38.850 --> 04:41.620
E para fazer isso, você vai ver agora como é tão simples.

04:41.640 --> 04:46.290
Isso é porque já temos o nosso cérebro em nosso corpo a partir da função init.

04:46.320 --> 04:56.190
Nós simplesmente precisamos levar nosso cérebro para o próprio cérebro e aplicar esse cérebro às imagens de entrada e isso irá propagar as

04:56.190 --> 04:59.830
coisas para a função alimentar aqui do cérebro.

05:00.430 --> 05:06.190
Isso irá propagar os sinais dentro do cérebro e uma vez que a função direta do

05:06.520 --> 05:13.600
cérebro retorna os sinais de saída que os neurônios da camada de saída que contêm valores de Q. Bem,

05:13.610 --> 05:19.030
essa entrada do cérebro aqui retornará esse sinal de saída e, portanto, vamos colocar aqui,

05:19.090 --> 05:26.120
seja ele transformado em uma variável e vamos chamar isso simplesmente supera essa saída é o sinal de saída

05:26.120 --> 05:26.690
do cérebro.

05:26.930 --> 05:31.970
o corpo e, para isso, vamos usar a segunda função de avanço do corpo e fazer isso.

05:31.970 --> 05:37.990
E agora, agora que temos o sinal de saída do cérebro. Bem, temos que propagar esse sinal de saída para

05:38.030 --> 05:46.370
Nós simplesmente precisamos tomar nosso corpo e aplicá-lo, claro, a saída porque a função Ford do corpo

05:46.370 --> 05:50.600
leva como entrada os sinais de saída do cérebro.

05:50.660 --> 05:55.880
Então é exatamente o que é o resultado agora e retorna as ações.

05:56.000 --> 05:58.080
E, portanto, desde que ele retorna as ações.

05:58.380 --> 06:03.530
Bem, aqui vamos adicionar ações para causar a própria produção.

06:03.920 --> 06:09.380
sinais dentro do cérebro e depois do cérebro até o primeiro, usando a função de forma do cérebro

06:09.380 --> 06:15.410
que nos leva e coloca as imagens de entrada e depois as propaga no cérebro para mantenha os valores-chave.

06:15.410 --> 06:19.830
Tudo bem, então agora você pode ver isso de forma muito simples, propagamos os

06:20.240 --> 06:25.400
E então propagamos esse sinal de saída para o corpo onde a função direta do nosso corpo para

06:25.520 --> 06:26.900
que a ação seja executada.

06:26.900 --> 06:32.300
E agora, o único restante que temos que fazer e essa é a última linha de

06:32.300 --> 06:34.510
código desta parte um construindo o.

06:34.760 --> 06:39.370
Temos que devolver a ação para jogar e isso é ação.

06:39.530 --> 06:45.020
ações têm que definir a tocha e precisamos convertê-las novamente por direito e, para isso,

06:45.260 --> 06:51.660
vamos levar a estrutura de dados dessas ações e, em seguida, adicionar aqui a função não-piloto e depois vamos.

06:51.890 --> 06:53.840
No entanto, no momento, as

06:53.840 --> 06:56.780
Agora, temos as ações que viramos no formato correto.

06:56.780 --> 06:58.040
Então, parabéns.

06:58.040 --> 07:00.660
Agora terminamos com esta primeira parte 1.

07:00.770 --> 07:03.410
Construímos a AI em três etapas.

07:03.410 --> 07:06.860
Primeiro fizemos o cérebro em segundo lugar, nós fizemos o corpo.

07:06.860 --> 07:13.430
E em terceiro lugar, montamos o cérebro no corpo e propagamos todo o sinal dos olhos até o momento

07:13.430 --> 07:15.130
em que tocamos a ação.

07:15.560 --> 07:17.100
Então, esse é um primeiro passo feito.

07:17.120 --> 07:22.200
Esse foi um grande passo, mas agora, como você entendeu, construímos um AI AI, mas ainda é estúpido.

07:22.220 --> 07:24.110
Precisamos treiná-lo para ser inteligente.

07:24.170 --> 07:29.030
Então precisamos treiná-lo para fazer o que queríamos fazer e para fazer isso, vamos usar a

07:29.030 --> 07:34.100
palavra para fazer ambientes que você conhece porque é aprender do mundo, sendo reforçada quando recebe uma

07:34.100 --> 07:34.690
boa recompensa.

07:34.760 --> 07:40.610
E ao ser punido ou enfraquecido quando está ficando uma palavra ruim, é aí que o aprendizado da sugestão

07:40.610 --> 07:41.670
entrará em jogo.

07:41.690 --> 07:47.510
E assim é exatamente o que faremos nesta parte para treinar nos olhos com o aprendizado Q convolucional profundo.

07:47.510 --> 07:50.270
Não posso esperar para começar e até então eu.