Olá e bem-vindo à parte super emocionante de nossa criação, a parte em que a tornamos inteligente.
Então é exatamente isso que acontece ao treinar o ar.
Vou treinar sua inteligência para atingir o objetivo que desejamos realizar.
E para fazer isso, vamos basicamente treinar a rede neural para gerar as previsões corretas.
E então tudo já está pronto porque esses sinais de saída do cérebro já têm a transmissão
certa para o corpo para executar as ações finais.
Então, basicamente, o que estamos prestes a fazer é algo que já fizemos antes.
Vamos apenas pegar alguns lotes aleatórios da memória, obter nossa entrada a partir dessas amostras, obter a saída,
obter o destino, obter as previsões, calcular o último erro entre as previsões e o destino e, em
seguida, executar a propagação para trás foi para obter a descida do gradiente para atualizar os pesos de acordo
com o quanto eles contribuíram para este último erro.
Então, vamos fazer tudo isso.
Você verá como será tão fácil porque já temos todas as ferramentas para implementar
isso.
Não só temos o caminho para ferramentas como o otimizador e as funções de perda, mas também temos todas
as classes que fizemos antes, como nosso cérebro, é claro, que vamos usar para obter
as previsões.
Em seguida, nossa experiência, replay do rastreamento de elegibilidade de implementação e todas essas ferramentas combinadas com o piloto,
ferramentas que farão o super desempenho do treinamento e, portanto, eventualmente, obteremos um A. super
poderoso. EU. Então vamos fazer esse treinamento acontecer.
Vamos tornar nossos olhos mais inteligentes.
E a primeira coisa que faremos agora é pegar a última função que usaremos durante
o treinamento ao calcular o erro e otimizá-lo.
Essa é a primeira coisa que faremos.
Então, vamos criar uma variável para a última função.
Vamos chamar de perda.
E isso será igual à função de perda MSE do módulo final.
E então aquele Mercilus.
Essa é a última função que usaremos porque basicamente nossas previsões são valores.
Você sabe, estamos prevendo os valores centrais das diferentes ações.
E, portanto, como esses são números reais, bem, estamos fazendo algumas redes neurais para regressão e, portanto, a
função de perda é o meio de erro.
Essa é a função de perda que usamos em geral para regressão.
Tudo certo.
Agora que temos nossa última função, vamos otimizar nosso otimizador aqui.
Essa é a variável que criamos para o otimizador.
E vamos levar como de costume.
Quanto ao carro que dirige sozinho, o otimizador Atom, é um otimizador muito poderoso que fará maravilhas para
o treinamento.
Então, vamos levar este até aquele átomo.
E lembre-se, isso é exatamente o que o carro autônomo que temos para inserir dois argumentos essenciais.
O primeiro é o que fará a conexão entre o otimizador e os parâmetros da nossa rede neural,
ou seja, os pesos dos neurônios do nosso cérebro.
E para fazer isso, pegamos nosso cérebro, que chamamos de CNN.
Esse é o objeto que criamos para nosso cérebro.
E assim a CNN que lembra os parâmetros que vamos e alguns parênteses.
Isso faz a conexão entre o otimizador e os pesos dos neurônios no cérebro
de nosso A. EU. E o segundo argumento é uma taxa de aprendizado, dada por l. R.
E então aqui temos que pegar uma taxa de aprendizado menor porque não queremos convergir muito rápido e queremos alguma
exploração e, portanto, uma boa forma de aprendizado que podemos dizer aqui é uma pequena que tem quatro
pontos ou um que é 0. 01 por cento.
Acho que é o mesmo que usamos para o carro autônomo.
Tudo bem, agora temos um otimizador de função perdida, então estamos quase prontos para iniciar o loop completo.
Bem, na verdade, vamos começar o loop completo agora.
Mas antes de fazermos isso, vamos decidir o tamanho do número de épocas que iremos
nos transformar e, portanto, criar uma nova variável aqui que responderá a esse número de épocas.
E vamos definir como cem.
Isso será suficiente para treinar o ar e eu até aposto que o ar vai conseguir chegar da melhor
maneira antes de cem como vinte ou trinta.
Vamos ver.
Mas, por enquanto, vamos pegar cem.
E se precisarmos, vamos aumentá-lo.
Mas não acho que isso seja necessário.
OK, agora que temos nosso número de aeroportos, podemos começar a fazer o loop completo,
você sabe, este loop principal completo do treinamento quando treinamos nos aeroportos.
Então, por enquanto, todo o vôlei estará em ação.
É isso que escolhemos para voltar.
Agora, é claro, vamos usar a função de intervalo para dizer que queremos ir do primeiro para
um número de aprox.
Mais um porque, lembre-se, o limite superior de um intervalo não está incluído e, portanto, se
você quiser ir até 100, bem, temos que especificar e ser um mais um para ir até 100.
Tudo certo.
Então, Colin.
E agora vamos entrar no loop.
Tudo certo.
Portanto, a primeira coisa que faremos é 200 execuções de dez etapas.
Assim, cada época será de 200 corridas, uma após a outra de 10 etapas.
E para fazer isso, temos esta função de uma etapa de nossa classe de experiência e, portanto, usar
essa função, que na verdade é um método porque a obteremos de nosso objeto de
memória, que é um objeto da classe de substituição para gerar essas duas execuções de dez etapas.
Bem, temos que pegar nosso objeto de memória que eu lembro que criamos bem aqui.
A memória é um objetivo para reproduzir a classe de memória com Insteps.
São 10 passos e uma capacidade de dez mil.
Nós criamos esse objeto e dele pegamos bem, essa função de Rundstedt executa etapas e especificamos
duzentas rodadas sucessivas de dez etapas para que, em cada uma, executemos basicamente 200 etapas.
E agora que temos essas 200 etapas em execução em cada apoc, bem, é hora de amostrar alguns lotes
dessas execuções e provar esses lotes.
Temos outra função em nossa memória, que é lote de amostra, e que irá gerar exatamente
alguns lotes dessas 200 execuções.
Mas lembre-se, esses lotes são, desta vez, lotes de uma série de transições que uma série de dez etapas, ao contrário
de antes, onde os lotes eram apenas alguns lotes de transições únicas aqui.
Desta vez, eles serão lotes de dez etapas, dez transições e, portanto, agora é
hora de obter de nossa memória esses lotes aleatórios e obtê-los.
Usamos a função de lote simples à qual temos de aplicar o tamanho do lote e para o tamanho do lote onde
podemos pegar trinta e dois ou mesmo sessenta e quatro ou mesmo cento e vinte e oito.
Lembre-se, para esse tamanho, é uma prática comum usar trinta e dois.
Isso é o que você verá em geral nas arquiteturas de redes neurais ao fazer algum aprendizado em lote.
Mas desta vez é bem diferente.
Nós, estamos apenas testando alguns lotes de 10 etapas, então é melhor pegar lotes com tamanhos maiores.
Então é aí que podemos pegar sessenta e quatro, cento e vinte e oito.
Então, vamos pegar cento e vinte e oito.
E, na verdade, isso vai estar dentro do loop porque queremos vários lotes e estamos pegando o que
é retornado por esta função de lote simples.
Portanto, este loop completo para lote em lote de amostra de memória, cento e vinte e oito significa que a cada cento
e vinte e oito etapas, bem, nossa memória nos dará um lote de tamanho cento e vinte e
oito, que conterá na verdade o último cento e vinte e oito passos que acabamos de dar.
Estamos recebendo apenas alguns lotes de seis, cento e vinte e oito e o aprendizado vai acontecer com
esses lotes.
E além desses lotes, teremos bandejas de elegibilidade funcionando, sabe, para aprender a cada 10
passos.
Tudo certo.
Então, agora dentro desse loop, que ainda está acontecendo em uma época, mas agora estamos em um lote
específico.
E agora a primeira coisa que faremos é obter nossas entradas e nossa meta separadamente.
E isso, como eu disse, é muito fácil.
Podemos fazer isso com uma das ferramentas que implementamos, que é o rastreamento de elegibilidade.
Como você pode ver aqui, esta função de rastreamento de elegibilidade leva o como entradas e agora temos o
lote e retorna como saída, as entradas e os destinos.
Portanto, agora, o que podemos simplesmente fazer é criar duas novas variáveis, que serão as entradas e
o destino.
E essas entradas chegam aos destinos é exatamente igual ao que retorna esta função de rastreamento de elegibilidade se aplica a um
lote.
Portanto, vamos aplicar essa função ao lote de nosso loop.
E então o que faremos é apenas elegibilidade.
Trace aplicado ao lote de nossa esperança.
Tudo bem, isso nos dá as entradas e os alvos, mas nos pães-duros sempre há algo mais que
precisamos fazer.
E, claro, isso converte a entrada da rede neural e também o alvo em algumas variáveis
tahj.
Mas também não há nada de novo.
Nós sabemos como fazer.
Podemos fazer assim.
Nós pegamos nossas entradas, então nossos alvos e bem, eles serão iguais ao verbal.
Input's.
Isso é para a entrada e verbal.
Alvos, e isso é para os alvos.
Tudo bem, então as entradas do cérebro são convertidas em algumas variáveis tahj e os alvos também são convertidos em
algumas variáveis tahj.
Agora podemos obter as entradas na rede neural.
E por que precisamos fazer isso?
Como a próxima etapa é obter as previsões, temos as entradas que precisamos atingir.
Agora, é claro, precisamos de nossas previsões, porque então o que acontece é que calcularemos a perda
entre as previsões e os alvos.
Então, vamos obter essas previsões para obtê-los.
Bem, novamente, isso é tão simples.
Agora só precisamos pegar nosso cérebro, que é a CNN, nossa rede neural convolucional, e
aplicá-la às nossas entradas.
Aqui vamos nós.
As entradas vão para a rede neural e a rede neural produzirá as previsões.
Perfeito, agora temos as previsões, temos as metas para que possamos obter as leis e esse é
o próximo passo, vamos apresentar um novo mais porque agora vamos obter o último erro, que é diferente
do que a última função, porque a usamos como uma função para obter o último erro.
Portanto, menos erro aqui e que o obteremos com menos função aplicada às nossas previsões e as metas que
vamos ver como tudo está bem agora.
Tudo é lógico.
Recebemos primeiro os dados de entrada, os alvos, depois, graças aos dados, obtemos as previsões.
E então, graças às previsões e metas que obtivemos, menos erros.
Muito lógico e suave, e agora qual é o próximo passo?
Bem, o mesmo caminho lógico agora que temos o último, podemos propagar esse erro menor de volta para a
nova rede para atualizar os pesos.
E fazemos isso com a descida gradiente estocástica e para realizar a descida gradiente estocástica.
Precisamos de nosso otimizador, mas já o temos.
Aqui está Adam Optimizer.
Mas agora, neste ponto, lembre-se do que temos que fazer.
Temos que inicializá-lo e inicializá-lo.
Lembre-se, pegamos nosso objeto otimizador e aplicamos o método de zero grad.
Lá vamos nós, não esquecemos os parênteses que o inicializam, e agora o próximo passo é
propagar o último erro de volta para a nova rede e fazer isso de onde pegamos nosso último
erro e aplicamos nele o método reverso.
Então, isso é exatamente para aplicar a propagação para trás.
E, finalmente, agora que o último erro voltou, propague-o para a nova rede.
Bem, podemos atualizar os pesos com a descida gradiente de Cassi.
E para fazer isso, lembre-se, pegamos nosso otimizador e aplicamos o método step.
Aqui vamos nós.
Os pesos agora estão atualizados.
Como eu disse, não só nós já fizemos, mas agora parece tão simples e natural.
Então, agora vamos fazer algo divertido.
Vamos imprimir a recompensa média a cada apoc.
Então, você sabe, podemos acompanhar como o A. EU. está indo, como está indo o treinamento.
Queremos ver a recompensa média aumentando ao longo das etapas, ao longo da caixa.
E no início, claro, há essa fase de exploração.
Portanto, a recompensa média pode não aumentar no início, mas depois que atinge a fase
de exploração, veremos a recompensa média aumentar definitivamente e aumentará até um certo nível, que é quando atinge
o oeste tão rápido quanto possível.
Então, vamos começar com a impressão.
Você sabe, estamos fazendo isso em um, então temos que voltar para a impressão de loopier
e então vamos imprimir bem, primeiro cerca de uma coluna, depois por cento.
S, porque vamos converter tudo em uma string que é melhor e depois vamos
adicionar a recompensa média.
E então adicionamos a porcentagem também, então vamos fechar a citação.
E então nós adicionamos uma porcentagem e do outro lado, você sabe, nós inserimos as variáveis que vão ser
a primeira pessoa, pois isso é o épico aqui e a segunda variável correspondente à recompensa média, que
será computada agora.
Portanto, a variável de recompensa média ainda não existe.
Vamos criá-lo agora mesmo.
Então, vamos usar o ETR no trabalho.
Mesmo que Époque seja o número, vamos convertê-lo em uma string.
Isso é melhor e.
Vamos adicionar, Estie, essa vai ser a recompensa média e, então, vamos
criar uma variável que vamos chamar de grande recompensa e agora vamos criar essa variável e computá-la ?
OK, então vamos fazer isso.
Essa é a única coisa que temos que fazer.
Então, Époque, já temos.
Agora vamos calcular o mundo médio e precisamos calculá-lo bem aqui.
Ainda no loop, mas fora do loop, porque agora temos nosso lote amostrado e nosso treinamento acontecendo
no lote.
Mas agora a propagação para a frente mais a propagação para trás são feitas no lote.
Portanto, estamos voltando ao ciclo e agora podemos calcular as recompensas cumulativas que podemos fazer com o nosso objeto do
peito do pé.
Como nosso objeto de peito do pé contém esta função, gostaríamos de etapas que nos permitem obter as recompensas cumulativas que acontecem
nas etapas, você sabe, durante a execução do peito do pé.
Portanto, vamos usá-lo agora para atualizar as novas recompensas das etapas.
Em seguida, atualizaremos o objeto de média móvel adicionando as recompensas cumulativas ao objeto diário móvel e, em
seguida, recalcularemos a média.
E é assim que vamos conseguir a recompensa média.
Então vamos fazer isso.
A primeira coisa de que precisamos são os dados DARABA das recompensas.
Então, vamos chamá-los de recompensas.
Passos e então, como dissemos, tomamos nosso objeto de passos finais, que foi, eu lembro, criado aqui um objeto da aula
de progresso instantâneo de nossa experiência que sujamos assunto tão sensível.
Em seguida, adicionamos recompensas, etapas e alguns parênteses.
Tudo certo.
Isso nos dará as novas recompensas cumulativas das etapas.
Tudo certo.
Mas então precisamos adicionar essas novas recompensas cumulativas em nossos objetos de média móvel.
E para fazer isso, temos um método desta vez na classe de média móvel, que é um método de anúncio muito
simples.
Pegamos nosso objeto de média móvel, que criamos aqui com cem passos.
Em seguida, vamos usar nosso método ADD e, na atmosfera, inserimos nossas etapas de recompensa e isso adicionará
as recompensas das etapas à média móvel.
Tudo certo.
E, finalmente, podemos calcular a recompensa média e isso é bom, você sabe, essa é a mesma variável aqui.
Então é isso que vai ser igual à recompensa média.
E para obtê-lo, só precisamos usar o método da média desta vez do nosso objeto de média móvel.
E isso é o que fazemos e uma média de pontos assim, porque nossa média móvel já foi atualizada com as novas
etapas de recompensas que acabamos de adicionar ao método ADD.
Ótimo.
Agora temos nosso prêmio médio, que é muito popular aqui e vai ser impresso todos os anos.
Tudo bem, então terminamos.
Estou muito animado para ver os resultados.
E, na verdade, terei uma surpresa para vocês no próximo tutorial enquanto observo os resultados.
Então, vai ser muito emocionante.
E agora acho que é hora de brincar com o ar e se divertir.
Tudo certo.
Portanto, prepare um bom café ou um bom chá.
Agora é hora de sentar confortavelmente em nossa cadeira e assistir a alguns vídeos muito legais do nosso avião para ver, que
está no próximo tutorial.
E até então, aproveite.