WEBVTT

00:00.300 --> 00:02.000
Olá e bem vindo a este tutorial.

00:02.160 --> 00:05.090
Parabéns novamente por ter terminado com isso.

00:05.150 --> 00:08.200
Veja, nós conseguimos que fizemos os cérebros e nós os treinamos.

00:08.400 --> 00:15.600
Mas agora ainda temos que fazer um agente de teste que não será uma data de amanha, mas que apenas

00:15.780 --> 00:19.430
usará o modelo de compartilhamento para fazer suas próprias explorações.

00:19.530 --> 00:26.080
E, claro, nesse código, vamos gravar alguns vídeos, e esses serão os agentes de teste de

00:26.090 --> 00:28.750
vídeos que aparecem com uma certa pontuação.

00:28.810 --> 00:30.840
Então vamos passar por este código.

00:30.850 --> 00:35.860
O mais importante é feito, pois eu disse que não vamos codificá-lo linha a linha, mas acho que

00:35.860 --> 00:38.580
é importante que você entenda o que está acontecendo aqui.

00:38.800 --> 00:42.680
Então, vamos com este código na primeira seção, como você notou.

00:42.790 --> 00:49.480
Nós importamos as bibliotecas e, então, encontramos essa função de teste que fará com que este agente de teste faça

00:49.480 --> 00:52.390
sua própria exploração e jogue o jogo de breakout.

00:52.600 --> 00:58.610
Então, nós conseguimos que esta função de teste leva três argumentos, o primeiro é o ranking que ainda precisa sincronizar

00:58.850 --> 01:02.060
o agente de teste como fizemos para os agentes de treinamento.

01:02.230 --> 01:05.380
Então nós temos nossos parâmetros, é claro, porque você precisa de alguns.

01:05.380 --> 01:12.220
E é claro que temos o modelo compartilhado porque este agente de teste usará um modelo compartilhado para fazer

01:12.220 --> 01:13.360
sua própria exploração.

01:13.360 --> 01:18.790
Tudo bem, entramos dentro da função e esta linha de código que sincronizamos com o agente de teste.

01:18.820 --> 01:23.120
Exatamente como fizemos antes, importamos o meio ambiente.

01:23.170 --> 01:27.070
Então lembro isso no código principal que será no próximo tutorial.

01:27.250 --> 01:33.970
Bem, o nome aqui será substituído por um intervalo de zero para que possamos entrar no ambiente zero

01:34.060 --> 01:40.180
e jogar o jogo e a Cruz Vermelha Trumans, que obterá os vídeos da nossa noite.

01:40.180 --> 01:46.680
Então, basicamente, esta linha de código no total significa que executamos um ambiente com vídeo.

01:47.080 --> 01:54.520
Então, na próxima linha de código, sincronizamos esse ambiente exatamente o mesmo princípio que a função Tendência.

01:54.700 --> 02:02.170
Em seguida, obtemos o nosso modelo e, para isso, criamos um objeto da classe de atividades e colocamos a forma de

02:02.170 --> 02:08.920
entrada com nosso espaço de observação ambiental e os zeros de forma são exatamente como a função do trem

02:09.190 --> 02:13.690
e nossas saídas, que são as ações com um espaço de ação.

02:13.900 --> 02:19.770
Então, exatamente como antes, algo novo aqui desde que terminamos com o treinamento.

02:19.870 --> 02:25.450
Nós não queremos colocar o modelo no modo trem porque simplesmente não queremos treinar,

02:25.450 --> 02:26.880
queremos colocá-lo em desenvolvimento.

02:27.160 --> 02:29.740
E é isso que fazemos aqui com o modelo que evoluiu.

02:29.890 --> 02:36.940
Então, é basicamente para colocar o agente de teste em um modo que basicamente testará o

02:37.030 --> 02:38.350
desempenho testado avaliado.

02:38.720 --> 02:45.680
Então, aqui, recebemos nossos estados de entrada, que são as imagens de entrada do jogo que neste momento são

02:45.680 --> 02:46.790
uma raça inteira.

02:46.840 --> 02:49.360
Então os convertemos em dançarinas de tocha.

02:49.480 --> 02:52.810
Aqui, inicializamos algumas das palavras aqui.

02:52.840 --> 02:54.980
Inicializamos para baixo para true.

02:55.200 --> 03:03.430
última vez, algo novo novamente, nós introduzimos este terceiro viável com uma função de tempo para medir o tempo de computação.

03:03.850 --> 03:05.990
Então, ainda assim, como a

03:06.190 --> 03:08.680
E isso é porque você quer começar o ponto de partida.

03:08.890 --> 03:15.160
Então, aqui, as ações que usamos um tipo de sugestão muito prática que permite adicionar um elemento à sugestão da

03:15.160 --> 03:16.550
direita ou da esquerda.

03:16.600 --> 03:21.960
Então, isso é muito prático e eu lhe darei a referência que penso na versão decrementada do código.

03:22.180 --> 03:27.320
Então você vai dar uma olhada no que é este dequeue e é isso que permite fazer isso.

03:27.490 --> 03:33.370
Em seguida, inicializamos o comprimento de um episódio com zero, é claro, e então incrementaremos o tamanho

03:33.400 --> 03:34.690
neste loop de bom.

03:34.870 --> 03:36.480
Então usamos o mesmo truque aqui.

03:36.680 --> 03:42.290
Embora seja verdade e no loop, incrementamos o comprimento do episódio em um.

03:42.490 --> 03:49.700
Quando o jogo termina quando o jogo acabou, recarregamos o último conjunto do modelo compartilhado do modelo de compartilhamento

03:49.730 --> 03:51.460
que datado pelos outros modelos.

03:51.460 --> 03:55.610
Lembre-se que aqui o modelo compartilhado já não é datado então.

03:55.660 --> 04:04.030
Ainda assim, se o jogo acabar se o jogo estiver pronto, Reinetaremos que reinicializamos os estados celulares, ver X e,

04:04.190 --> 04:13.840
em seguida, Estados H x e, de outro, se o jogo não estiver bem, nós mantemos os mesmos estados celulares e nos estados.

04:13.840 --> 04:18.030
Mas para se certificar de que eles são ensinados variável para que eles possam ser anexados a um gradiente.

04:18.170 --> 04:25.240
OK, então é algo que já morreu na função de tendência e, em seguida, ainda no ciclo de tempo e depois

04:25.240 --> 04:30.870
de ter um dado que indica nos estados ocultos da maneira certa, dependendo dos dois casos aqui.

04:31.060 --> 04:34.360
Bem, o que fazemos, obtemos as previsões de amanhã.

04:34.450 --> 04:37.380
É exatamente isso que fazemos aqui com essa linha de código.

04:37.750 --> 04:43.360
Então, obtemos o valor que é o resultado do crítico, o valor real que é o resultado do ator.

04:43.600 --> 04:49.750
E, em seguida, é até todos os estados ocultos H x e os estados celulares do X, então geramos uma

04:49.750 --> 04:54.130
distribuição de probabilidades das ações que estão no valor de ação de valores Q aqui.

04:54.270 --> 04:56.380
E fazemos isso com a próxima função.

04:56.470 --> 05:01.230
E é claro que não precisamos ter probabilidades de sorte aqui porque isso é apenas para treinamento para

05:01.480 --> 05:02.650
o agente de teste.

05:02.650 --> 05:09.130
Simplesmente jogará as ações que acabamos de usá-lo, você conhece como uma determinada atividade para desempenhá-la, mas

05:09.190 --> 05:10.920
não estamos treinando aqui.

05:10.960 --> 05:19.040
Então, temos apenas um suporte e, disto, jogamos a ação, levando diretamente ao RMX dessas probabilidades, e

05:19.040 --> 05:22.720
é preciso a ação que tem maior probabilidade.

05:22.810 --> 05:26.860
E a razão é que o agente de teste não faz nenhuma exploração.

05:26.860 --> 05:32.830
máxima novamente, então, uma vez que tocamos a ação, chegamos ao próximo estado e recebemos a próxima palavra.

05:32.830 --> 05:38.170
Lembre-se de que queremos ter a chance de adotar algumas ações que têm baixas probabilidades quando você

05:38.170 --> 05:44.260
quer fazer alguma exploração dessas outras ações e você não sabe tomar cada vez que a ação que tem

05:44.260 --> 05:50.800
a maior probabilidade, mas aqui o agente de teste pode fazer qualquer exploração e portanto, é por isso que nós

05:50.800 --> 05:53.340
tomamos diretamente a ação que tem a probabilidade

05:53.470 --> 05:56.920
E é um dia datado se o jogo acabou ou não.

05:57.160 --> 06:03.700
Então, conseguimos tudo isso com esta linha de código, jogando a ação depois de selecioná-la com o nosso

06:03.790 --> 06:04.630
Max aqui.

06:04.840 --> 06:13.000
de novo e então, uma vez que acabamos de obter uma nova recompensa Vamos atualizar algumas das recompensas simplesmente adicionando esta nova palavra.

06:13.090 --> 06:18.950
Então, nós jogamos a ação aqui e nós conseguimos o estado, recebemos a recompensa e fizemos isso

06:19.180 --> 06:21.480
E, finalmente, sempre que o jogo estiver pronto.

06:21.490 --> 06:28.510
Então, se isso significa que quando o jogo estiver pronto quando terminar de jogar bem, vamos imprimir

06:28.510 --> 06:31.210
os resultados com o tempo o oposto.

06:31.230 --> 06:36.100
Nós queríamos o comprimento do episódio, que é quanto tempo durou.

06:36.100 --> 06:42.890
Jogando bem e isso é exatamente como imprimimos todas essas variáveis ​​usando esses pequenos truques.

06:42.910 --> 06:46.280
Isso é para o tempo em que queremos que seja apenas uma variável.

06:46.340 --> 06:51.960
Algumas das palavras e idéias são o comprimento do presente OK.

06:52.160 --> 06:57.860
E então, uma vez que imprimimos todos os resultados bem desde o fim do jogo e queremos começar

06:58.220 --> 06:59.930
um novo jogo, vamos reinicializar tudo.

06:59.930 --> 07:04.170
Essa é a soma de duas palavras zero o comprimento de um episódio para zero.

07:04.230 --> 07:10.100
Vamos reescrever todas as ações, usando esta função de tecla, restaura as imagens de

07:10.100 --> 07:13.360
entrada que você conhece repetindo todas as quebras.

07:13.610 --> 07:21.980
E, finalmente, usamos esse tempo que dorme 60 segundos para fazer uma pausa de um minuto para permitir que os outros

07:21.980 --> 07:22.840
agentes praticem.

07:22.850 --> 07:24.810
E isso se o jogo acabar.

07:25.210 --> 07:25.840
ESTÁ BEM.

07:25.940 --> 07:32.210
E, finalmente, temos essa última linha de código que nos dará o novo estado e então podemos avançar.

07:32.240 --> 07:34.550
Podemos continuar neste novo jogo.

07:34.550 --> 07:35.840
Então vamos lá.

07:35.870 --> 07:37.430
Essa é a função de teste.

07:37.430 --> 07:40.550
Coisas às quais você verá os vídeos em um ou dois tutoriais.

07:40.550 --> 07:45.310
Espero que você seja como a última vez para assistir os resultados que está com você.

07:45.350 --> 07:47.360
Curial e eu, que será divertido.

07:47.480 --> 07:48.400
E eu estou lhe dizendo.

07:48.440 --> 07:50.330
Espere ver bons resultados.

07:50.360 --> 07:55.130
Mas lembre-se de que este jogo foi muito desafiador.

07:55.130 --> 07:58.430
Achamos que era um jogo simples para jogar primeiro, mas não em absoluto.

07:58.430 --> 08:01.480
Na verdade, tornou-se muito mais difícil do que a destruição.

08:01.670 --> 08:03.890
E é por isso que o colocamos no último módulo.

08:04.190 --> 08:09.510
Mas, de qualquer forma, vamos fazer essa função principal no próximo tutorial.

08:09.590 --> 08:11.770
Mesmo isso não é o mais importante aqui.

08:11.780 --> 08:18.860
Agora que o A-380 é demente, não codificamos linha a linha, expandirá o código e, muito

08:18.980 --> 08:20.570
rapidamente, obteremos os resultados.

08:20.570 --> 08:22.130
Até então, desfrute da AI.