WEBVTT

00:00.560 --> 00:02.560
Olá e bem vindo a este tutorial.

00:02.750 --> 00:04.610
Agora temos o cérebro do amanhã.

00:04.610 --> 00:06.350
Nós também temos o otimizador.

00:06.350 --> 00:09.980
Então, basicamente, estamos prontos para treinar nossos diferentes agentes.

00:10.010 --> 00:11.620
Esse é o nosso cérebro diferente.

00:11.720 --> 00:18.650
Então, a partir daqui, isso fará com que essa grande função de trem contenha todo o algoritmo A3 e, portanto,

00:18.650 --> 00:24.920
o que estamos prestes a implementar neste trem que encontrei é apenas esta enorme função de trem que

00:25.230 --> 00:31.200
só será essa grande função de trem nada mais não classe, mas quem usará esta função de trem.

00:31.250 --> 00:33.880
E o último passo deste módulo com o código principal.

00:34.100 --> 00:35.010
Então vamos lá.

00:35.060 --> 00:37.340
Mas antes de começar, você pode perceber isso.

00:37.490 --> 00:42.020
Bem, primeiro importamos algumas bibliotecas para que sejam as bibliotecas clássicas com o módulo da tocha.

00:42.020 --> 00:49.040
Quero dizer, sua biblioteca de tocha e depois termina a biblioteca para criar o ambiente que irá sair.

00:49.220 --> 00:54.470
Então vamos, naturalmente, importar são realmente aulas de nosso modelo.

00:54.620 --> 00:55.980
Arquive esta.

00:56.420 --> 01:00.070
E, finalmente, usaremos uma variável da TORCIDA.

01:00.150 --> 01:04.000
Lamento correr competições de alto desempenho no gradiente.

01:04.100 --> 01:05.750
Graças aos gráficos dinâmicos.

01:05.990 --> 01:11.960
E, então, temos essa função de graduação compartilhada garantida, que eu não queria gastar muito tempo

01:11.960 --> 01:16.930
nisso porque, bem, isso é apenas uma função que assegurará que tudo funcione corretamente.

01:17.030 --> 01:20.400
Se o modelo usado pelo agente não tiver nenhum gradiente de compartilhamento.

01:20.480 --> 01:25.640
É por isso que se chama grads compartilhados curtos e a outra razão é que eu não acho que essa

01:25.640 --> 01:26.530
função seja necessária.

01:26.630 --> 01:32.700
menos, com isso será 100% seguro de que o código será executado corretamente, mas isso não é realmente importante.

01:33.080 --> 01:34.790
Mas nunca sabemos e, pelo

01:34.880 --> 01:40.640
O que devemos focar é essa função de tendência que todos começamos a fazer agora.

01:41.000 --> 01:41.600
Aqui vamos nos.

01:41.610 --> 01:48.860
Def e train tornar-se-ão rapidamente um trem e esta transformação levará vários argumentos.

01:49.010 --> 01:50.400
O primeiro é o ranking.

01:50.420 --> 01:56.460
Eu vou explicar o que é e o segundo o segundo é harams para que todos os parâmetros

01:56.460 --> 01:57.840
sejam o meio ambiente.

01:57.920 --> 02:02.860
Então, o terceiro parâmetro será compartilhado com a moral.

02:03.170 --> 02:09.260
Então, você sabe que o modelo compartilhado é o que o agente conseguirá executar sua pequena

02:09.260 --> 02:17.050
exploração em um certo número de etapas e, finalmente, o último argumento será o otimizador que é o que fizemos anteriormente.

02:17.770 --> 02:20.040
Tão perfeito é o argumento.

02:20.090 --> 02:24.010
E agora estamos prontos para começar a implementar a mesma função.

02:24.170 --> 02:30.890
Então, a primeira coisa que faremos é que você sabe que você lembra do que significa A-380, que representa agentes

02:31.010 --> 02:32.480
crônicos ativos e síncronos.

02:32.540 --> 02:34.980
Então, em 8: 3, veja que há um síncrono.

02:34.980 --> 02:40.940
classificação aqui é apenas para mudar a semente para que cada agente de treinamento seja sincronizado.

02:40.940 --> 02:49.010
Então, como você entendeu, temos que desautorizar cada agente de treinamento e deseconomias, então vamos usar a classificação para mudar cada

02:49.220 --> 02:52.230
lado com essa classificação, então esse parâmetro de

02:52.580 --> 02:59.390
Então, por exemplo, se houver algum agente de treinamento, as classificações irão de 1 a 10 e haverá

02:59.390 --> 03:02.600
um inteiro por agente de 1 a 10.

03:02.630 --> 03:08.840
Então, quando mudamos a semente por um segmento, todos os números pseudo aleatórios criados por este

03:08.840 --> 03:11.340
tópico serão totalmente independentes dos outros tópicos.

03:11.480 --> 03:14.250
No entanto, a semente ou números fixos.

03:14.510 --> 03:19.640
Então, quando reproduzimos a experiência, encontraremos exatamente os mesmos eventos.

03:19.880 --> 03:23.450
E isso é porque é determinista em relação ao assento.

03:23.690 --> 03:30.470
Portanto, é importante entender isso e é por isso que precisamos fazer é sincronizar cada agente estagiário usando o

03:30.800 --> 03:34.260
direito aqui para mudar a semente com a classificação.

03:34.350 --> 03:36.110
Então vamos fazer isso para fazer isso.

03:36.140 --> 03:39.170
Vamos pegar a nossa biblioteca Torche.

03:39.170 --> 03:45.350
Então, vamos pegar a semente com parênteses de semente de sublinhados manuais.

03:45.350 --> 03:51.040
Esta é uma função e agora vamos tomar as sementes de todos os agentes com os

03:51.220 --> 03:55.620
quais podemos acessar com essa semente e deslocá-los pela classificação para sincronizar.

03:55.660 --> 04:05.420
Cada um desses agentes apenas adicionará aqui mais rec e que mudará a semente com a classificação para desrespeitar cada agente

04:05.510 --> 04:09.970
estagiário porque há uma semente para cada agência de treinamento.

04:09.980 --> 04:15.390
Tudo bem, primeira coisa feita e agora próxima etapa, o próximo passo é obter o ambiente.

04:15.530 --> 04:21.470
Então, vamos criar uma nova variável que vamos chamar e agora usaremos para criar o Atari e

04:21.590 --> 04:26.120
funcionar a partir do módulo final para criar o ambiente para o breakout.

04:26.150 --> 04:28.130
Isso é para obter o ambiente de sair.

04:28.250 --> 04:38.070
Então, nós tomamos essa função criar Terry e agora temos que inserir apenas um argumento que são os parâmetros

04:38.070 --> 04:39.060
do ambiente.

04:39.270 --> 04:42.730
E nós os temos porque essa é uma das entradas da função cerebral.

04:42.750 --> 04:48.270
Este é este parâmetro aqui, que será os parâmetros do ambiente de

04:48.330 --> 04:58.320
breakout e, portanto, para obter os ambientes breakout, tomamos esses argumentos de programas, então, e então obtemos um nome no futuro que

04:58.320 --> 05:03.240
está no próximo código com a função principal que irá executar

05:03.240 --> 05:06.010
todo o código será Breaker Brachial Vizier.

05:06.010 --> 05:09.450
Tudo bem para que o ambiente seja perfeito.

05:09.610 --> 05:16.080
E agora o próximo passo é alinhar o assento do ambiente em um dos agentes.

05:16.180 --> 05:17.650
E por que fazemos isso.

05:17.650 --> 05:24.220
É porque lembre-se de cada agente do A-3 Silmaril tem sua própria visão do meio ambiente como sua

05:24.220 --> 05:31.000
própria cópia do meio ambiente e, portanto, precisamos alinhar cada um dos agentes em uma versão específica do ambiente

05:31.000 --> 05:36.520
e para fazer isso, estamos indo para usar o assento porque cada assento determina um

05:36.520 --> 05:37.320
ambiente específico.

05:37.450 --> 05:43.390
Então, ao associar uma semente diferente a cada agente bem, obteremos exatamente o que queremos,

05:43.390 --> 05:46.340
é que cada agente terá seu próprio ambiente.

05:46.500 --> 05:54.730
E então, como podemos fazer isso, podemos levar o nosso meio ambiente, em seguida, usar a função de semente para que você saiba escolher

05:54.770 --> 05:57.340
os que ele recebe para o meio ambiente.

05:57.520 --> 06:01.370
E agora, alinhe o assento do ambiente à semente do agente.

06:01.600 --> 06:08.460
Bem, simplesmente precisamos obter isso, porque isso corresponde ao assento do agente que foi deslocado para classificar para

06:08.530 --> 06:14.170
obter agentes de treinamento organizados decentes, porque eles estão todos em um conjunto diferente.

06:14.200 --> 06:20.020
Então, só precisamos pagar isso aqui e isso irá alinhar o assento do ambiente em um

06:21.210 --> 06:24.660
do agente. Ok, agora vamos buscar o nosso modelo.

06:24.670 --> 06:27.060
Esse é o nosso A-3 ver cérebros.

06:27.180 --> 06:32.320
E agora é que vamos usar a classe ativa do nosso arquivo modelo.

06:32.350 --> 06:38.500
dessa classe de atividade e vamos chamar este modelo de objeto ou cérebro, se você quiser.

06:38.500 --> 06:40.960
Então, basicamente, vamos criar um novo objeto

06:41.200 --> 06:47.650
Mas, basicamente, esse objeto conterá todas as circunvoluções do CM. A conexão linear e a função

06:47.650 --> 06:49.500
Ford para propagar o sinal.

06:49.600 --> 06:55.630
Então, basicamente, irá conter os cérebros do ator no crítico com a capacidade de propagar o

06:55.630 --> 06:59.120
sinal em todo o cérebro para obter o resultado final.

06:59.170 --> 07:06.850
Então, vamos fazer isso, vamos criar nosso modelo, assim como dissemos que queremos chamar esse modelo de objeto.

07:07.150 --> 07:15.040
E assim criamos um objeto do ato criar classe e, portanto, tomamos um crítico de ator de classe e agora lembramos

07:15.040 --> 07:17.250
quais argumentos quando os dois insumos.

07:17.350 --> 07:20.420
Na verdade, são os argumentos da função.

07:20.640 --> 07:26.230
Então, nós temos que inseri-lo, você sabe que é o que temos que fazer para usar o objeto no método.

07:26.530 --> 07:33.010
Mas, em seguida, os argumentos que temos de colocar são nomeados que estão em mau estado e que são feitos em

07:33.010 --> 07:38.680
cadeias de arte em imagens impressas e o espaço real que contém você conhece o conjunto de ações.

07:38.680 --> 07:42.550
Então, vamos colocar esses argumentos na função de trem.

07:42.760 --> 07:51.580
Então, o primeiro que podemos obtê-lo com o nosso ambiente e isso e, em seguida, usamos espaço de observação que é o espaço

07:51.580 --> 07:59.020
de observações, então, e então você obtém o número de entradas que obtem o zero do suporte de sombra.

07:59.190 --> 07:59.550
Tudo bem.

07:59.550 --> 08:01.120
Isso é para insumos.

08:01.290 --> 08:04.690
E agora para o espaço de ação.

08:04.860 --> 08:10.480
Bem, isso é quase o mesmo que precisamos obtê-lo do nosso ambiente, que somos importantes do que isso.

08:10.500 --> 08:12.920
E, em seguida, espaço de ação.

08:12.920 --> 08:13.260
Tudo bem.

08:13.260 --> 08:17.860
E isso nos dá os argumentos que precisamos inserir ao criar um objeto.

08:17.860 --> 08:20.130
O modelo da classe execrate.

08:20.400 --> 08:25.150
Ok, então agora temos nosso modelo e agora o próximo passo é preparar nossos estados de entrada.

08:25.170 --> 08:31.230
Então lembre-se de que ainda estamos fazendo uma aprendizagem informal mais profunda para que a entrada indique nossas imagens de

08:31.560 --> 08:37.080
entrada e, portanto, isso será originalmente feito por Ray, que conterá um canal porque trabalhamos com imagens em

08:37.080 --> 08:40.670
preto e branco e terá tempo nos oceanos de 42 por 42.

08:40.980 --> 08:46.680
Mas é importante entender e ter em mente aqui que os estados de entrada são imagens de entrada.

08:46.680 --> 08:51.940
Então, o que temos de fazer é obter o não-poder, então o converteremos em uma resposta de tortura.

08:52.050 --> 08:57.770
Mas o primeiro passo como o que fizemos anteriormente é obter um árbitro e obtê-lo.

08:57.840 --> 08:58.970
Na verdade, é bastante simples.

08:58.980 --> 09:06.080
criar uma variável para o estado de entrada que irá cruzar o estado e isso para obter uma matriz de árbitros.

09:06.080 --> 09:07.130
Bem, primeiro, precisamos

09:07.230 --> 09:13.000
Nós simplesmente precisamos tomar o nosso ambiente e, em seguida, adaptar e, em seguida, usar a função de reinicialização.

09:13.200 --> 09:19.940
E isso irá inicializar os Estados como uma matriz do império de dimensões um por 42 até 42.

09:20.190 --> 09:27.170
Um significa 1 canal, de modo a imagem em preto e branco e 42 por 42 é, claro, as dominações da imagem.

09:27.210 --> 09:30.860
O número de pixels e a largura eo número de pixels e a altura.

09:30.870 --> 09:32.630
Então, basicamente, isso é apenas a instância do tempo.

09:32.670 --> 09:34.660
E esses são os que trabalhamos.

09:34.820 --> 09:40.830
isso realmente em arbitragem, porque isso nos obterá essas imagens desse seguro de tempo no Empire.

09:40.830 --> 09:42.670
E agora, agora que temos

09:42.870 --> 09:48.510
Agora podemos convertê-los em dançarinas de tocha e para fazer isso bem, nós estamos indo para um estado de dados

09:48.510 --> 09:50.890
novamente porque não precisamos manter os arrays de números.

09:51.180 --> 09:55.030
E é aí que usamos a tocha no módulo da tocha.

09:55.260 --> 10:02.790
E lembre-se de que já fizemos isso com a função do parêntese de sublinhado não tailandês.

10:02.880 --> 10:08.350
E, dentro desta função, precisamos inserir a taxa de número que queremos converter em um sensor de tocha.

10:08.610 --> 10:14.880
E esse é o estado em que a versão anterior da matriz de não pagamento do estado se tornará pipelineada

10:14.880 --> 10:20.510
da função de tubulação de um sensor de tocha, de modo que apenas crie mais intenso do estado.

10:20.550 --> 10:24.870
E agora só precisamos inicializar o viabilizado.

10:24.870 --> 10:30.650
Lembre-se de que a variável é geralmente a variável que diz se um episódio acabou ou se o jogo acabou.

10:30.870 --> 10:37.110
Bem, aqui só queremos apresentar isso muito bem e inicializar para verdade, para especificar que este

10:37.160 --> 10:41.230
Não Voivode será igual a verdadeiro quando o jogo estiver concluído.

10:41.260 --> 10:46.790
Isso será útil para mais tarde, para que o AI não jogue indefinidamente para sair.

10:46.820 --> 10:47.350
Tudo bem.

10:47.390 --> 10:54.320
Então, esse foi basicamente o início dessa função de tendência com alguma inicialização e algumas coisas que

10:54.320 --> 10:55.370
temos que fazer.

10:55.370 --> 11:00.560
A parte mais importante aqui foi que devemos desistir de cada agente estagiário.

11:00.560 --> 11:04.890
Esse é um primeiro princípio do A3 que temos de aplicar.

11:05.160 --> 11:09.780
E agora, no próximo tutorial, procederemos à sincronização com o modelo compartilhado.

11:09.830 --> 11:14.810
Não esqueçamos que existe um modelo diferente, mas também o modelo de compartilhamento que é um modelo

11:14.810 --> 11:16.180
que todos os agentes compartilham.

11:16.190 --> 11:22.430
E então temos que sincronizar com o modelo de exibição para que cada agente possa obter esse modelo compartilhado para

11:22.520 --> 11:25.990
proceder a uma pequena exploração de um certo número de etapas.

11:26.000 --> 11:28.080
Então, é o que faremos no próximo Statoil.

11:28.130 --> 11:29.710
E até então, desfrute da AI.