WEBVTT

00:00.390 --> 00:02.710
Olá e seja bem vindo ao Spice Intertoto.

00:03.000 --> 00:07.800
Tudo bem, então, nesta nova seção de código, vamos implementar a experiência com o jogo.

00:07.920 --> 00:13.850
Então, vamos fazer uma nova aula, a qual chamaremos memória de repetição e que implementará a experiência para

00:13.850 --> 00:16.700
jogar exatamente como você viu nas palestras de intuição.

00:16.890 --> 00:21.540
Mas primeiro vamos dar uma lembrete rápido sobre o que é a repetição da experiência.

00:21.540 --> 00:27.750
Então, você sabe que toda essa inteligência artificial é baseada em processos de decisão de Markov e os processos

00:27.750 --> 00:31.840
de decisão de Markov consistem na análise de uma série de eventos.

00:32.010 --> 00:38.770
Então, os eventos que você conhece, por exemplo, vão de um estado para outro e tipis um.

00:39.060 --> 00:44.410
Mas se os eventos fossem bem assim, desde o próximo dia está muito correlacionado com o estado atual.

00:44.550 --> 00:46.820
Bem, a rede não faria muito bem.

00:46.980 --> 00:52.710
Então, para aqueles que vêm do curso de aprendizado profundo exatamente o mesmo que onde aprendemos nossas

00:52.710 --> 00:54.860
séries temporais com apenas um timestep.

00:55.020 --> 01:00.300
Não estava aprendendo nada porque um timestep não era suficiente para que um modelo

01:00.300 --> 01:03.070
aprendesse a entender as correlações de longo prazo.

01:03.090 --> 01:07.060
Então é o mesmo aqui e é por isso que temos que implementar a repetição da experiência.

01:07.230 --> 01:08.230
Então, como isso funciona.

01:08.340 --> 01:13.960
Bem, isso é muito simples em vez de considerar o estado atual que é apenas um estado no

01:13.960 --> 01:14.640
tempo t.

01:14.680 --> 01:16.830
Vamos considerar mais no passado.

01:16.830 --> 01:22.560
Então, exatamente como para lítio e, portanto, nossa série de eventos não será tão.

01:22.560 --> 01:27.450
E eu suponho que este será, por exemplo, os cem estados no passado.

01:27.450 --> 01:33.770
Então, como T-menos cento e oitenta menos 99 até menos 1 e depois S-T.

01:34.020 --> 01:40.830
o que chamamos de memória e é por isso que temos uma memória de longo prazo em oposição a uma memória

01:40.830 --> 01:47.040
de curto prazo ou mesmo que eu digo uma memória instantânea e que faça todo o processo funcionar muito melhor.

01:47.040 --> 01:49.950
Então, em outras palavras, colocamos 100 transições menores para

01:50.310 --> 01:57.690
E então, uma vez que criamos essa memória dos últimos 100 eventos, simplificaremos que levem

01:57.690 --> 02:02.300
alguns lotes aleatórios dessas transições para fazer nossa próxima atualização.

02:02.310 --> 02:09.270
Essa é a nossa próxima jogada ao selecionar a próxima seção e, portanto, nesta classe de memória de repetição

02:09.270 --> 02:13.450
que estamos implementando para a repetição da experiência, faremos três funções.

02:13.530 --> 02:17.490
Em primeiro lugar, a função como de costume é o caso de qualquer classe.

02:17.520 --> 02:23.400
E assim, nesta função, definiremos as variáveis ​​que serão anexadas às futuras instâncias da classe que

02:23.400 --> 02:27.210
são os objetos futuros que serão criados a partir desta classe.

02:27.540 --> 02:32.790
E muito simplesmente essas variáveis ​​serão a memória das 100 transições para 100 eventos.

02:32.970 --> 02:38.790
E a capacidade que é o número 100 você será bem-vindo para tentar uma memória mais longa aumentando

02:38.790 --> 02:39.550
a capacidade.

02:39.780 --> 02:46.170
Então, essa é a primeira função na função e então vamos fazer duas outras funções uma função de

02:46.500 --> 02:51.050
empurrar para garantir que a memória não contenha mais de 100 transições.

02:51.180 --> 02:57.150
E para isso, usaremos a capacidade apenas fazendo uma condição simples e, eventualmente,

02:57.360 --> 03:03.300
faremos a função simples e, claro, será provar algumas transições nesta memória das

03:03.390 --> 03:05.060
últimas 100 transições.

03:05.520 --> 03:08.440
Tudo bem, então comecemos por apresentar a aula.

03:08.520 --> 03:17.460
Então, como você sabe, começamos com a aula e depois os damos para a classe que chamamos de memória de

03:17.460 --> 03:25.500
repetição e, em parênteses, nós inserimos o objeto, então, Cullin e então nós começamos com a primeira função.

03:25.560 --> 03:26.860
O fim é função.

03:27.150 --> 03:30.730
Então é exatamente o mesmo que antes de começar com a morte.

03:30.870 --> 03:36.750
Então dois sublinhados neles dois sublinhados novamente e depois as variáveis.

03:36.750 --> 03:42.750
instâncias da classe de objetos futuros e então teremos outra variável para você poder

03:42.750 --> 03:48.810
experimentar alguma outra experiência com algumas das memórias e isso vai acontecer seja a capacidade.

03:48.810 --> 03:52.950
Então, é claro que é a variável anexada às futuras

03:52.950 --> 03:58.020
Então, essa capacidade será simplesmente o número 100, porque vamos fazer experiência para

03:58.020 --> 04:00.960
jogar com as transições de cem menos.

04:00.960 --> 04:03.910
Tudo bem e depois Collon E aqui vamos nós.

04:03.930 --> 04:10.430
Vamos entrar na função e vamos definir as variáveis ​​do nosso objeto de memória de repetição.

04:10.440 --> 04:19.400
Assim, o primeiro será a capacidade autodidata e, como você provavelmente entendeu, essa será a capacidade que é o número

04:19.670 --> 04:24.690
máximo de transições que queremos ter em nossa memória de eventos.

04:24.830 --> 04:30.980
ao criar um objeto da classe de memória de repetição e, portanto, isso é capacidade.

04:31.000 --> 04:34.530
E isso será igual aos argumentos que entrarão

04:34.550 --> 04:36.480
Esse é o argumento da função init.

04:36.660 --> 04:38.180
Então, capacidade.

04:38.180 --> 04:44.960
Então, novamente, para não se confundir, essa capacidade é o nome da variável que está anexada ao objeto

04:45.470 --> 04:52.670
e a capacidade aqui é o argumento que irá inserir ao criar um objeto da classe de memória de repetição.

04:52.810 --> 04:53.620
Tudo bem.

04:53.830 --> 04:55.880
E então temos um segundo voivode.

04:56.170 --> 04:57.890
Essa é, claro, a memória.

04:58.000 --> 05:01.620
Auto-escolar Nemec.

05:01.760 --> 05:02.650
Tudo bem.

05:02.800 --> 05:05.730
E então, para o que será essa memória Voivode.

05:05.990 --> 05:13.950
Bem, esta memória deve conter os últimos 100 eventos e, portanto, isso deve ser um teste simples.

05:14.100 --> 05:20.300
Você conhece uma lista que conterá os últimos 100 eventos nas últimas 100 transições e para inicializar

05:20.300 --> 05:20.850
a lista.

05:20.870 --> 05:24.620
Não há nada mais simples, apenas adicionamos alguns colchetes assim.

05:24.740 --> 05:26.040
E aqui vamos nós.

05:26.060 --> 05:31.490
Nossa memória é inicializada, é claro, no início da experiência ou mais precisamente o início

05:31.490 --> 05:36.430
da exploração, a memória será uma lista vazia e depois colocamos as transições.

05:36.500 --> 05:38.350
Cada vez que chegamos a um futuro estado.

05:38.600 --> 05:43.370
E, falando sobre isso, é exatamente o que faremos com a próxima função que

05:43.520 --> 05:44.720
chamaremos a função push.

05:44.790 --> 05:51.380
Vamos fazer essa função de empurrar para plantar os eventos nesta lista de memória e depois usaremos a

05:51.620 --> 05:57.170
capacidade de garantir que esta lista de memória sempre contenha 100 eventos e nunca mais.

05:57.500 --> 05:59.660
Tudo bem, então vamos fazer isso no próximo também.

05:59.690 --> 06:01.250
E até então eu.