Olá e seja bem vindo ao Spice Intertoto.
Tudo bem, então, nesta nova seção de código, vamos implementar a experiência com o jogo.
Então, vamos fazer uma nova aula, a qual chamaremos memória de repetição e que implementará a experiência para
jogar exatamente como você viu nas palestras de intuição.
Mas primeiro vamos dar uma lembrete rápido sobre o que é a repetição da experiência.
Então, você sabe que toda essa inteligência artificial é baseada em processos de decisão de Markov e os processos
de decisão de Markov consistem na análise de uma série de eventos.
Então, os eventos que você conhece, por exemplo, vão de um estado para outro e tipis um.
Mas se os eventos fossem bem assim, desde o próximo dia está muito correlacionado com o estado atual.
Bem, a rede não faria muito bem.
Então, para aqueles que vêm do curso de aprendizado profundo exatamente o mesmo que onde aprendemos nossas
séries temporais com apenas um timestep.
Não estava aprendendo nada porque um timestep não era suficiente para que um modelo
aprendesse a entender as correlações de longo prazo.
Então é o mesmo aqui e é por isso que temos que implementar a repetição da experiência.
Então, como isso funciona.
Bem, isso é muito simples em vez de considerar o estado atual que é apenas um estado no
tempo t.
Vamos considerar mais no passado.
Então, exatamente como para lítio e, portanto, nossa série de eventos não será tão.
E eu suponho que este será, por exemplo, os cem estados no passado.
Então, como T-menos cento e oitenta menos 99 até menos 1 e depois S-T.
o que chamamos de memória e é por isso que temos uma memória de longo prazo em oposição a uma memória
de curto prazo ou mesmo que eu digo uma memória instantânea e que faça todo o processo funcionar muito melhor.
Então, em outras palavras, colocamos 100 transições menores para
E então, uma vez que criamos essa memória dos últimos 100 eventos, simplificaremos que levem
alguns lotes aleatórios dessas transições para fazer nossa próxima atualização.
Essa é a nossa próxima jogada ao selecionar a próxima seção e, portanto, nesta classe de memória de repetição
que estamos implementando para a repetição da experiência, faremos três funções.
Em primeiro lugar, a função como de costume é o caso de qualquer classe.
E assim, nesta função, definiremos as variáveis ​​que serão anexadas às futuras instâncias da classe que
são os objetos futuros que serão criados a partir desta classe.
E muito simplesmente essas variáveis ​​serão a memória das 100 transições para 100 eventos.
E a capacidade que é o número 100 você será bem-vindo para tentar uma memória mais longa aumentando
a capacidade.
Então, essa é a primeira função na função e então vamos fazer duas outras funções uma função de
empurrar para garantir que a memória não contenha mais de 100 transições.
E para isso, usaremos a capacidade apenas fazendo uma condição simples e, eventualmente,
faremos a função simples e, claro, será provar algumas transições nesta memória das
últimas 100 transições.
Tudo bem, então comecemos por apresentar a aula.
Então, como você sabe, começamos com a aula e depois os damos para a classe que chamamos de memória de
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.
O fim é função.
Então é exatamente o mesmo que antes de começar com a morte.
Então dois sublinhados neles dois sublinhados novamente e depois as variáveis.
instâncias da classe de objetos futuros e então teremos outra variável para você poder
experimentar alguma outra experiência com algumas das memórias e isso vai acontecer seja a capacidade.
Então, é claro que é a variável anexada às futuras
Então, essa capacidade será simplesmente o número 100, porque vamos fazer experiência para
jogar com as transições de cem menos.
Tudo bem e depois Collon E aqui vamos nós.
Vamos entrar na função e vamos definir as variáveis ​​do nosso objeto de memória de repetição.
Assim, o primeiro será a capacidade autodidata e, como você provavelmente entendeu, essa será a capacidade que é o número
máximo de transições que queremos ter em nossa memória de eventos.
ao criar um objeto da classe de memória de repetição e, portanto, isso é capacidade.
E isso será igual aos argumentos que entrarão
Esse é o argumento da função init.
Então, capacidade.
Então, novamente, para não se confundir, essa capacidade é o nome da variável que está anexada ao objeto
e a capacidade aqui é o argumento que irá inserir ao criar um objeto da classe de memória de repetição.
Tudo bem.
E então temos um segundo voivode.
Essa é, claro, a memória.
Auto-escolar Nemec.
Tudo bem.
E então, para o que será essa memória Voivode.
Bem, esta memória deve conter os últimos 100 eventos e, portanto, isso deve ser um teste simples.
Você conhece uma lista que conterá os últimos 100 eventos nas últimas 100 transições e para inicializar
a lista.
Não há nada mais simples, apenas adicionamos alguns colchetes assim.
E aqui vamos nós.
Nossa memória é inicializada, é claro, no início da experiência ou mais precisamente o início
da exploração, a memória será uma lista vazia e depois colocamos as transições.
Cada vez que chegamos a um futuro estado.
E, falando sobre isso, é exatamente o que faremos com a próxima função que
chamaremos a função push.
Vamos fazer essa função de empurrar para plantar os eventos nesta lista de memória e depois usaremos a
capacidade de garantir que esta lista de memória sempre contenha 100 eventos e nunca mais.
Tudo bem, então vamos fazer isso no próximo também.
E até então eu.