Olá e bem vindo a este tutorial do Python.
Tudo bem, então, hoje estaremos criando a função de atualização que atualizará tudo o que há até
o momento, assim que o olho atinja um novo estado.
Então, quando chega a um novo estágio, você sabe que precisamos atualizar a ação.
O último realmente vem a nova ação que acabou de ser jogada.
Mas também a última data que se torna o novo estado.
E, finalmente, a última palavra que se torna a nova palavra que recebemos quando tocamos a ação.
Então esse é o caminho lógico que acontece logo após selecionar uma ação.
Precisamos atualizar todos os elementos das transições.
E, claro, você terá uma nova transição.
Então, teremos de acrescentar esta nova transição para a memória.
E, finalmente, também atualizaremos ou recompensaremos a janela que você sabe para manter um olho na evolução de como
o treinamento está indo e como a exploração está indo.
finalmente estabelecer uma conexão entre a IA que estamos implementando agora no nosso mapa, porque se retornarmos
ao nosso mapa, lembre-se de que esta função de atualização Beiji está na classe de jogo e Foi aí
que estávamos realmente fazendo o jogo com o carro e definindo como o carro deveria ser punido quando cometeu um erro.
Mas o que é mais importante para você entender é que agora podemos
Mas nesta classe de jogos percebemos esta função de atualização e nesta função de atualização percebemos
essa ação de linha porque a atualização do cérebro por último, trabalhamos menos sinal.
E, na verdade, isso é exatamente o que estamos prestes a fazer.
Estamos prestes a tornar esta função de atualização que levará a última palavra e o último sinal para que a
próxima ação seja executada.
Portanto, não só a atualização de todos os diferentes elementos da transição.
estamos prestes a selecionar para selecionar a direção a desempenhar além de fazer todas as atualizações.
Mas principalmente, estaremos jogando a ação que devemos tocar ao obter a última palavra e o último sinal e,
claro, nesta função de atualização, usaremos a função de ação selecionada que acabamos de implementar antes
de integrar a função de ação selecionada na função de atualização futura que
Então, isso é realmente importante para fazer essa conexão com o mapa agora.
O que estamos prestes a fazer é, eventualmente, a conexão entre o nosso olho e o jogo, o jogo que
fazemos nesta classe.
E então, o que podemos fazer agora é tomar diretamente esta atualização.
último, ficamos menos sinal, porque essa é realmente a função que faremos com esses dois argumentos aqui.
Por
E, assim como um lembrete rápido, o cérebro é o nosso objeto de AI que é o objeto da classe de Dejuan.
Então, o que vamos fazer agora é que vamos copiar esta atualização menos sinal de menos palavras e essa será
a nossa próxima função que estamos fazendo.
E, portanto, colando isso aqui, apenas para ter cuidado, eu gostaria de dar alguns nomes
diferentes dos nomes que temos aqui.
Você sabe que temos a última palavra aqui e não quero confundir esta última palavra com essa.
Isso pode ser perigoso.
Então, vou substituir a última palavra aqui por palavra.
E, do mesmo modo, por menos sinal, vamos apenas colocar sinal ou mesmo novo sinal para especificar que você sabe que queremos
medir isso ao chegar a um novo estado e, portanto, obter um novo sinal.
Mas, claro, essa palavra aqui será a última recompensa que chegamos aqui.
Você sabe quando vai em alguma areia ou pior se aproximando de uma borda do mapa, onde é que
definimos a última palavra.
Esta última palavra vai ser a entrada da função de atualização, então é por isso que temos a última palavra aqui.
Mas aqui estou apenas dando outro nome para o argumento.
Nós queremos não confundi-lo com a última palavra aqui.
Tudo bem, então esta é a função de atualização.
E agora vamos entrar e vamos fazer essas duas coisas.
Esse é o dado de todos os elementos da nossa transição e, claro, selecionar a ação.
OK então, o que precisamos para atualizar primeiro.
Bem, como você entendeu, queremos fazer uma data quando chegar a algum estado.
Então, a primeira coisa que vamos atualizar é, obviamente, esta notícia de que essa é a notícia de que estamos a alcançar.
Então, vou chamar esse novo estado novo estado e depois o farei.
E então, como podemos obter esse novo estado.
Bem, claro, isso depende do sinal do novo sinal de detecção dos sensores.
E, como lembrete, o estado é o próprio sinal composto dos três sinais que os sensores
sinalizam um sinal para sinalizar três orientação mais e menor orientação.
Esse é o nosso estado.
Portanto, certifique-se de entender que o sinal é o estado.
Mas agora é uma lista simples de cinco elementos.
que esta será a entrada para fazer todo o trabalho, lembre-se de que devemos convertê-lo em um sensor de tocha.
E uma vez
Então é exatamente o que vamos fazer agora.
Vamos pegar a nossa biblioteca de tochas e, em seguida, levar a classe de tensor lá, vamos converter o nosso novo
sinal em uma torch mais densa, então é melhor certificar-se de que todos os elementos da tocha para
responder são flutuadores, então eu vou faça uma conversão de tipo para convertê-los em flutuadores como este.
E, finalmente, tente obter um reflexo sobre o que precisamos fazer em seguida.
É claro que crie aquele motor falso para adicionar diamantes e corresponda ao
lote e nós fazemos isso, claro, com a função de aperto a que devemos colocar o índice deste grande diamante.
E queremos para o lote que é zero.
Tudo bem.
E agora temos nossos novos estados compostos dos três sinais dos três sensores mais
orientação menos orientação e, claro, que dependerão do novo sinal que estamos recebendo com esta função de atualização.
Direito neste último último sinal, recebemos os três sinais.
Então, além disso, ou além disso, e como lembrete, os três sinais são a densidade do sensor
detectado em torno dos sensores.
Tudo bem.
Então, nós conseguimos uma nova etapa, então significa que chegamos ao novo estágio e agora temos que fazer a próxima atualização.
Então, de acordo com você, o que precisamos atualizar agora.
Qual seria a coisa lógica até agora, depois de alcançar esse novo estado.
Bem, o que precisamos agora é a memória.
Por que é que.
É porque, a cada tempo, uma transição é composta pelo estado atual Estey no dia seguinte como tipis
quando a recompensa arti e a ação 80.
e já temos 80 e acabamos de obter o último elemento da transição Estep plus one.
E agora, já temos S-T, já temos nossa equipe
Então, obtendo este novo estado tão profundo como um, estamos recebendo uma nova transição da memória e, portanto, temos
que acrescentar esta nova transição para a memória, porque essa é simplesmente nossa próxima transição.
Então é por isso que temos essa memória agora.
E, portanto, o que eu vou fazer é tirar o meu objeto de memória criado a partir da
classe de memória de repetição e, portanto, eu vou levar a memória para se referir ao objeto.
Mas desde que eu estou usando o eu, tenho que incluir o auto naquela função.
Então, agora você pode realmente ver o que é esse eu.
É sempre que você usa uma variável que você criou e inicializou na função init aquela memória.
E agora nós fizemos isso.
E de acordo com você, como vamos atualizar isso.
Bem, a boa notícia é que já fizemos uma função para fazer isso.
É a função de envio que proíbe um evento ou uma transição para a memória.
Então é exatamente isso que vamos usar agora.
de empurrar para encadear nossa nova transição que acabamos de fazer na memória e, portanto, aqui
não aceito igual porque usaremos o método e, portanto, podemos usar esse impulso diretamente.
Nós vamos usar a função
E primeiro vou adicionar a transição da nova transição que acabamos de receber e que é a
primeira data.
Então você mesmo na última data.
Então, isso é S-T. É exatamente esse que já existe.
Então, o próximo elemento dessa transição é, naturalmente, o novo estado que acabamos de alcançar.
E, portanto, uma vez que não é viável do objeto que criamos e inicializamos nesta função init,
não nos colocamos aqui.
Nós colocamos diretamente o Newstead, então o próximo elemento da transição é a ação e diz que já temos a última
seção que é essa auto que a última ação aqui.
Então, é claro que é igual a zero.
Mas, claro, será atualizado com a função de ação selecionada.
Mas esse é esse.
Então, é eu mesmo a última ação.
Mas agora tenha cuidado.
Os elementos que foram incluídos nesta transição devem ser todas respostas apagadas.
Como você pode ver, esse é o caso da última data.
É um sensor de tocha.
O novo estado também é respondido.
E isso deve ser o mesmo para a ação e depois a recompensa, é claro.
Mas agora você vai pensar como pode ser uma resposta torched considerando que é simplesmente um número.
Você sabe que a ação é 0 1 ou 2.
Mas na verdade, isso não é um problema.
Ainda podemos converter essa variável 0 1 ou 2 em um sensor de tocha.
Este será apenas o que chamamos de tensor longo.
O longo é um tipo e esse é o tensor que conterá um número inteiro porque a última
ação é um inteiro é 0 1 ou 2.
Então, o que vamos levar agora é o nosso torche de biblioteca, então vamos levar a longa e longa
classe de tensor que criará um objeto que será o próprio não-mandato.
E, ao assumir esta última função de ação como entrada, ela criará esse objeto tensor longo, mas ainda conterá
0 1 ou 2 em um objeto tensor longo e isso é apenas para ser consistente com a transição que ele só contém
tensores porque estamos trabalhando com a tocha PI e estamos trabalhando com uma rede neural.
Então, temos que trabalhar com sensores para que possamos responder longamente.
E uma última conversão para fazer.
Devemos ter certeza de que o que está dentro dessa longa resposta é um número inteiro e para se certificar
disso mesmo se já sabemos que a última ação é 0 1 ou 2 para se certificar de que vamos
fazer essa conversão de tipo int novamente, nós convertemos nossos auto ação final em um inteiro.
Lá vamos e, em seguida, devemos colocar essa ação inteira inteira em colchetes aqui mesmo, para que agora possamos um
tensor longo de um elemento que será essa última ação 0 ou 1 ou 2 em si.
Então, o ponto-chave é que é exatamente como você converte um número simples zero um ou dois em um tensor com torche.
Tudo bem.
E, finalmente, o último elemento da transição e, claro, a última palavra que obtivemos.
Essa é exatamente a última palavra voleibol que criamos em qualquer função que foi inicializada para zero.
Mas, claro, é atualizado aqui neste código, quer quando adentrarmos um sentido que é uma palavra negativa ou
se nos afastarmos do objetivo que é novamente uma recompensa negativa.
Se nos aproximarmos do objetivo, é uma recompensa positiva e a pior punição se chegarmos muito perto de uma
borda do mapa. Bem, essa é uma terrível palavra negativa menos uma.
E isso é um.
Então vamos adicionar este último elemento da transição auto-direcionar a palavra.
Então eu estou copiando esse colar aqui e agora temos que fazer outra conversão que será, naturalmente, exatamente a
mesma como essa apenas porque a palavra não é um número inteiro, mas um número flutuante.
Nós simplesmente faremos uma tocha que a conversão do tensor, mas sem isso manterá os colchetes aqui porque você sabe primeiro,
temos que colocar o número em uma lista e, em seguida, esta lista irá e colocará a tocha na
classe, mas não temos para fazer isso na conversão porque a última palavra é um número flutuante.
Então, o que vamos fazer é simplesmente adicionar aqui um tensor de ponto de torqueira que provocou um tensor e, em seguida, parênteses entre parênteses.
E vamos fechar os colchetes aqui e fechamos os parênteses.
Aqui vamos nós.
Então, para resumir O que você disse que acabamos de chegar e a palavra que observamos um novo evento de
transição que adicionamos à memória.
E esta transição contém a última data e vê o novo estado como tipis quando a última
ação toca 80 e a última palavra Archie.
Tudo bem.
E agora vamos com nossa memória de datas.
Então vamos dar uma pausa rápida e nós iremos cuidar da próxima atualização no próximo tutorial.
Até então, eu.