WEBVTT

00:00.450 --> 00:02.520
Olá e bem vindo a este tutorial.

00:02.520 --> 00:06.140
Tudo bem, agora temos a nossa AI, está pronto para ser treinado.

00:06.330 --> 00:09.660
E o primeiro passo do treinamento é configurar nossa experiência de repetição.

00:09.900 --> 00:11.330
Então estamos chegando lentamente lá.

00:11.340 --> 00:16.690
O treinamento e a boa notícia é que temos uma versão implementada da repetição da experiência.

00:16.830 --> 00:23.490
Além disso, é adaptado ao rastreamento de elegibilidade que eu lembro é uma técnica que, ao invés de

00:23.490 --> 00:27.160
aprender os valores q, cada transição aprende cada 10 transições.

00:27.210 --> 00:29.460
Então, basicamente, isso é exatamente o mesmo que antes.

00:29.490 --> 00:35.190
Mas em vez de ter um único alvo, uma única palavra para cada etapa, teremos um alvo cumulativo

00:35.190 --> 00:40.770
de dez passos e uma recompensa cumulativa de 10 etapas e aprenderemos as 10 etapas de cada vez.

00:40.980 --> 00:44.960
Então estamos aprendendo em transições 10 etapas em vez de uma como antes.

00:45.180 --> 00:50.440
E com isso vou fazer maravilhas e isso fará algumas maravilhas para o processo de treinamento.

00:50.440 --> 00:52.570
Você sabe que o treinamento levará muito menos tempo.

00:52.620 --> 00:58.850
Graças a esta técnica, temos de especificar a repetição da inexperiência que estamos aprendendo cada 10 etapas.

00:58.980 --> 01:04.230
Então, é por isso que essa repetição da experiência não é uma implementação clássica da reprodução da experiência.

01:04.320 --> 01:06.160
Como fazer um para o carro auto-dirigido.

01:06.210 --> 01:12.540
É uma implementação de repetição de experiência levando em conta este 10 passos de aprendizagem e, portanto, você

01:12.540 --> 01:19.110
encontrará neste arquivo de repetição de experiência duas classes uma classe que faz seu progresso AI fazer dez

01:19.110 --> 01:23.460
passos para que possa somar as recompensas são observadas nestas 10 etapas.

01:23.460 --> 01:28.430
Essa é a primeira classe e precisamos desta aula, porque precisamos incluir esses 10 passos na classe de memória

01:28.430 --> 01:33.570
de repetição, que é o implemento da sala de aula pela experiência que jogamos e é assim que nos certificamos

01:33.630 --> 01:38.020
de que a memória também leva em consideração o fato de que somos aprendendo em 10 etapas.

01:38.040 --> 01:42.660
Então, é por isso que você encontrará duas classes nesta implementação de reprodução de experiência, mas

01:42.660 --> 01:49.070
isso é apenas para levar em conta que estamos aprendendo em 10 etapas e isso também deve ser levado em consideração na memória.

01:49.410 --> 01:51.940
Então, falando sobre nossa memória, vamos criá-la.

01:51.970 --> 02:00.150
Vamos chamar nossa memória de memória e a memória será um objeto do elenco de memória de repetição e a classe de

02:00.570 --> 02:04.900
memória de repetição é uma classe dessa experiência de reprodução no momento.

02:05.070 --> 02:14.430
E então estou tomando primeiro essa experiência de experiência repetida e é aí que eu levo a classe de memória

02:15.180 --> 02:15.880
de repetição.

02:15.960 --> 02:16.840
Perfeito.

02:16.890 --> 02:23.460
E agora você pode ver que temos que colocar dois argumentos, o primeiro argumento e as etapas que correspondem

02:23.640 --> 02:27.540
exatamente ao número de etapas nas quais vamos aprender os valores-chave.

02:27.540 --> 02:32.090
Então, você conhece o número de etapas nas quais acumulamos o alvo e queremos.

02:32.180 --> 02:37.290
Nós teremos um alvo cumulativo e a recompensa cumulativa e, em seguida, o segundo argumento é

02:37.290 --> 02:39.840
a capacidade que é o tamanho da memória.

02:39.840 --> 02:42.650
Então, por exemplo, aqui podemos ver dez mil.

02:42.810 --> 02:48.270
Então, se a capacidade for igual a 10000, isso significa que teremos um tamanho

02:48.270 --> 02:54.210
de 10000 e, portanto, isso significa que teremos uma memória dos 10000 passos realizados pelo olho.

02:54.390 --> 02:57.390
Mas, novamente, não vamos aprender todas as transições.

02:57.390 --> 03:02.690
passos da memória e é exatamente esse novo recurso que apresentamos aqui em comparação com o anterior.

03:02.700 --> 03:06.100
Nós vamos aprender cada dez passos ao longo dos últimos 10000

03:06.180 --> 03:12.480
Antes de termos apenas esse truque de memória de repetição e aqui temos esse truque de memória de repetição

03:12.570 --> 03:16.920
mais esse truque aprendi cada dez passos e vamos aprender cada dez passos

03:16.920 --> 03:20.000
e vamos fazê-lo na memória composta pelo últimos 10000 passos.

03:20.190 --> 03:27.810
E esta é uma repetição experiente combinada a traços de inadimplência com 10 etapas, irá melhorar consideravelmente o

03:27.810 --> 03:29.240
desempenho do treinamento.

03:29.490 --> 03:31.130
Então vamos terminar com esses dois argumentos.

03:31.200 --> 03:35.900
O primeiro é e os passos e isso será igual.

03:36.030 --> 03:43.180
Mas, por enquanto, digamos, as etapas especificarão o passo certo depois que ele será realmente um abjeto da

03:43.360 --> 03:49.130
outra classe desse arquivo de repetição de experiência, que é a classe de progresso

03:49.140 --> 03:52.170
final e que permite progredir durante dez etapas.

03:52.170 --> 03:57.990
E lembre-se durante as 10 etapas, vamos tocar as palavras nas dez etapas para obter as recompensas

03:58.050 --> 03:59.550
cumulativas em 10 etapas.

03:59.550 --> 04:02.250
E esse é exatamente o teste de elegibilidade.

04:02.250 --> 04:09.350
Então, agora, o que temos a fazer é criar estes passos aqui e criá-lo com a segunda classe que temos

04:09.360 --> 04:13.040
neste arquivo de repetição de experiência, que é um progresso gradual.

04:13.160 --> 04:24.430
Então, agora vamos criar etapas neste e isso será um objeto da classe de progresso

04:24.430 --> 04:30.650
de etapas que retomamos de nossa experiência que jogamos.

04:30.940 --> 04:31.720
Aqui vamos nós.

04:31.840 --> 04:37.160
Então, essa é a classe anti-progresso e agora temos que colocar três argumentos, como você pode ver,

04:37.180 --> 04:41.010
temos que colocar o ambiente que é o ambiente aqui que importamos.

04:41.230 --> 04:47.680
Então o segundo argumento é a nossa AI e isso será, claro, a AI

04:47.830 --> 04:55.550
que construímos aqui na U. S. e o último argumento é passo nisso, onde especificamos que queremos

04:55.570 --> 04:59.120
10 etapas que você conhece para aprender cada 10 etapas que são cada 10 transições.

04:59.200 --> 05:01.140
Então, vamos ajudar com esses argumentos.

05:01.180 --> 05:06.920
O primeiro é o meio ambiente e isso é ruim e tudo bem.

05:06.940 --> 05:11.700
Então o segundo é o nosso AI AI e que nós contamos ai ai.

05:11.830 --> 05:12.720
Esse é o único aqui.

05:12.760 --> 05:17.590
Então, este é apenas o nome do argumento da classe de progresso do passo e ai ai ai.

05:17.590 --> 05:19.730
Aqui está o ai ai ai.

05:19.750 --> 05:27.150
Aquele que nós construímos e, em seguida, o último argumento é e pilha e isso é igual a 10.

05:27.160 --> 05:27.910
Tudo bem.

05:27.910 --> 05:33.670
Então, agora, estamos apenas levando em consideração na memória que há uma aprendizagem em 10 etapas e

05:33.670 --> 05:37.210
essa aprendizagem em 10 etapas é chamada de rastreamento de elegibilidade.

05:37.240 --> 05:39.520
Então estamos realmente trabalhando no material avançado aqui.

05:39.640 --> 05:44.160
Mas lembre-se que é porque estamos tentando ser Dume, que não é como fazer um pedaço de bolo.

05:44.290 --> 05:47.650
Então, precisamos dessas técnicas avançadas para fazê-lo funcionar.

05:47.660 --> 05:48.880
Então agora estamos quase prontos.

05:48.880 --> 05:55.450
é a capacidade, é claro, e é, digamos, 10000 homens, teremos um tamanho de 10000,

05:55.450 --> 06:03.730
o que significa que a memória conterá o último 10000 passos realizados pela AI e isso nos permitirá gerar alguns.

06:03.730 --> 06:11.470
Antes de avançar para o próximo passo que será realmente sobre a implementação de bandejas LGBT, a única

06:11.500 --> 06:13.810
coisa que temos que incluir

06:13.930 --> 06:16.020
Como eu me lembro, era uma função simples.

06:16.180 --> 06:22.840
Você sabe que a memória contém 10000 transições, mas para treinar o olho, vamos testar tantos lotes

06:22.840 --> 06:28.360
de dez transições, não comparados a antes das 10 transições desta vez, e amostraremos

06:28.360 --> 06:33.490
esses mini lotes de 10 transições na memória, composta pelos 10000 passos .

06:33.490 --> 06:38.770
Tudo bem, então agora eu acho que estamos prontos para passar para o próximo passo, que é sobre a implementação do

06:38.770 --> 06:39.490
rastreio de elegibilidade.

06:39.520 --> 06:41.680
Então vamos ter alguma aventura aqui.

06:41.680 --> 06:43.690
Esta não será uma implementação simples.

06:43.720 --> 06:47.830
Então, faça uma boa pausa e, quando estiver pronto, podemos atacar isso.

06:47.920 --> 06:49.120
E então, aproveite.