Olá e bem-vindo a este tutorial, este brinquedo especial vai ser super emocionante porque nos aproximamos
do A. S. C. algoritmo.
Você vai ver que o que estamos prestes a implementar e que é chamado de rastreamento de
elegibilidade ou Sarsour é realmente um algoritmo dos algoritmos de agentes de críticos ativos síncrona que não podemos
considerá-lo.
um agente, mas ainda assim você verá que o que estamos prestes a
implementar é realmente tirado do seguinte artigo, que é este documento como método Synchronoss para aprendizagem de reforço
profundo e é Neste artigo, você encontrará algoritmos A-3 que implementaremos como bônus final deste curso.
E nós vemos porque ainda vamos ter
Mas, como eu disse, estamos nos aproximando porque o modelo que vai implementar agora é realmente
esse, o síncrono e o secularizado, aquele que é quase o A3 C que está fazendo depois disso,
mas com um agente e o poderoso sobre isso é Este e passo Cunanan, vamos aprender a acumular recompensas
e aprender o alvo cumulativo em etapas finais em vez de um passo como Priestley.
E é isso que vai fazer o treinamento muito mais desempenho e, portanto, são muito mais poderosos.
Então, nós realmente temos o pseudo código para este algoritmo, é esse algoritmo aqui.
Então vamos clicar nele e lá vamos nós.
Esse é o algoritmo que estamos prestes a implementar.
Mas lembre-se com apenas um agente, a diferença é que eles tomam uma ação.
80 de acordo com a política do presidente Greely com base nos valores de q para o estado atual e a
ação tocada.
Mas, no nosso caso, não implementamos uma excelente política verde.
Implementamos um Max macio.
Mas o resto é o mesmo que você pode ver.
Vamos calcular o acumulado em que trabalhamos e, na verdade, 10 etapas.
Lembre-se que os passos são iguais a 10.
E então vamos implementar esta linha de código em nosso algoritmo que estamos prestes a implementar agora.
Nós vamos conseguir isso.
E principalmente, vamos implementar isso também.
Você verá que obteremos o máximo dos valores de q para o estado atual e a
ação atual neste theta.
Aqui está apenas um parâmetro de destino.
Então, vamos fazer isso, vamos atacar esse algoritmo.
Este é chamado de aprendizado síncrono e avançado.
Mas não temos o direito de dizer síncrono, tanto quanto estamos preocupados, porque só temos um motor.
Mas, portanto, podemos chamá-lo e aprender o rastreio de elegibilidade ou mesmo o Sarsour.
Tudo bem, então vamos fazer isso.
Vai ser muito divertido.
Nós podemos basicamente seguir o código aqui e é isso que vamos fazer.
E, assim como você pode ver um parâmetro que precisaremos, é novamente o parâmetro que é o
parâmetro de decaimento e, portanto, vamos começar por introduzir uma variável para este parâmetro Gahanna e escolhê-los.
Então vamos fazer isso.
Na verdade, não precisamos de uma sala de aula tremenda. Podemos simplesmente implementar isso com uma função,
porque você sabe que realmente não precisamos criar objetos para que este seja um modelo de
modelo, uma função será suficiente porque basicamente o que queremos fazer é devolver as entradas eo alvo para que, mais tarde,
ao treinar o AI, estamos prontos para minimizar a distância entre as previsões e o alvo e para obter as
previsões, precisamos das entradas, porque vamos aplicar o nosso cérebro na entrada para obter a saída sinais que
serão nossas previsões.
prontos para treinar a IA tentando minimizar essa grande distância entre as previsões e os banheiros.
E então, uma vez que tenhamos nossas previsões e nossos objetivos, estaremos
Então, esse é o objetivo de fazer isso agora.
Estamos implementando esta função para poder retornar essas entradas nos soviéticos para que possamos estar
prontos para o treinamento para minimizar as previsões de distância quadradas gerenciar banheiros.
Tudo bem, então vamos fazer isso, como dissemos, queremos implementar funções.
Começamos com isso.
Isto, vamos chamar a elegibilidade, ressaltou o rastreamento.
Você também pode chamá-lo de Sarsour.
Você também pode chamá-lo de dar um passo para tocar o que quiser, mas vamos chamar ele
de rastreabilidade e esta função vai levar um argumento que vai ser um lote e por que é
porque vamos conseguir algumas insumos e alguns objetivos porque Nós vamos treinar o AI em lotes.
E assim, as entradas e os alvos irão dentro de alguns lotes e, portanto, o argumento de
entrada aqui é esse lote que conterá várias entradas e, em seguida, vários destinos que serão computados.
Então vamos lá.
Esse é o único argumento que precisamos.
Agora vamos dentro de uma função e vamos definir o que precisávamos fazer.
Então, como vimos na Basílica do artigo, precisamos novamente os parâmetros, como dissemos, começamos por introduzir
este parâmetro gama semi-fechado e já podemos decifrar o valor.
E vamos escolher quatro nove e nove, que é um bom valor clássico para o Gana e Norreys.
Eu verifiquei que este é um bom valor para a nossa AI.
Tudo bem, então, o próximo passo no próximo passo é preparar nossa entrada e nossos objetivos, porque é exatamente isso
que queremos retornar.
Queremos devolver os insumos em metas para preparar o treinamento.
isso é ao inicializar as entradas como uma lista, bem como os alvos que vamos.
E então podemos inicializá-los com uma lista vazia, claro, essas entradas dentro do
melhor, vamos ter várias entradas em uma lista e
Então, inicializamos nosso e colocamos nossos objetivos e, no final, essa função de rastreamento de elegibilidade
retornará exatamente essas entradas.
E estes sim eram, naturalmente, Filton.
Temos várias entradas e as várias metas associadas no que será retornado pela função.
Tudo bem próximo ao próximo passo é iniciar um loop e é exatamente porque estamos seguindo o
código lento do papel.
Esse tipo de código.
E, como você pode ver, há esta seção de código repetido e repetido exatamente um loop completo no código.
Vamos calcular a recompensa cumulativa aqui acumulada durante as 10 etapas.
E como é computado.
Bem, em cada passo que não é o último passo, vamos conseguir o máximo dos valores principais da moeda
em que estamos durante este e os passos executados.
E se alcançarmos o último estado dos 10 passos, isso será igual a zero.
Isso é que não queremos fazê-lo mais.
E então temos esse loop para o qual será outro.
Eles não dizem repetir aqui, mas é o mesmo, será o segundo ciclo completo em nosso algoritmo.
Bem, nós teremos em que nós estávamos assim multiplicando pelo parâmetro de decaimento gama e adicionando
a palavra.
Então, vamos fazer isso, vamos voltar para Python e vamos começar o nosso completo.
E qual será a variável iterativa.
Bem, essa será a nossa série de 10 passos.
vamos chamar essa série variável que representa uma série de 10 transições como uma seqüência de 10 transições.
Você conhece nossa série de 10 transições, então
Então, para séries em.
E então, o que você acha.
Bem, nossa série será baixa em nosso lote.
Há os lotes em que irá treinar a AI e assim por diante série em lote que é para todas as séries
de 10 transições em nosso lote de entrada.
Bem, onde vamos fazer bem em obter uma recompensa cumulativa, você verá na sílica que precisamos
do estado da primeira transição da série e também do estado da última transição da série.
Então, o que temos que fazer agora é obter esses estados de entrada e, portanto, vamos colocar
estes dois estados em uma viabilidade que chamaria entrada e nós obteremos esses dois estados de entrada.
A primeira da série e a última que vamos colocar em uma matriz não-piloto, mas sem preocupações, não ficará
com isso e Ampyra, claro, converterá isso em um horrível, mas o primeiro
passo é colocar esses dois indica o primeiro no último em um império.
da série e que é Series e, em seguida, levá-la para uma transição, tomamos o índice zero da
série que é a primeira transição e depois podemos acessá-lo tomando seus atributos que é o estado e isso
porque, em nosso arquivo de repetição de experiência, encontramos uma estrutura especial para cada transição e você conhece a estrutura.
E então aqui mesmo, nesta matriz, adicionamos a primeira entrada, que é a fase de entrada
da primeira transição
Cada transição é composta por um estado de uma palavra de ação.
Mas, em seguida, o último elemento que é feito para que esta estrutura especial que nós possamos usar
agora venha da forma como definimos a transição e a experiência de repetição.
Tudo bem, então, com isso, obtemos o estado de entrada da primeira transição e agora podemos obter também
o estágio de entrada da última transição da série.
podemos acessar com este truque menos uma série menos aquele que receberá o estado de entrada do último transição da série.
E para fazer isso, é dizer que podemos copiar isso e colá-lo e substituir, como você está
aqui, pelo último índice da série a que
Tudo bem, então, precisamos colocar esses dois elementos dentro de alguns colchetes porque é o que se espera do árbitro
uma função e, então, uma coisa importante a fazer, uma vez que vamos converter isso em uma
resposta de tocha em uma variável de tocha.
Bem, lembre-se de um tensor da tocha é, por definição, uma matriz especial contendo um único tipo.
E então precisamos forçar um único tipo.
escolher o tipo de flutuador e, assim, adicionar esse parâmetro aqui D tipo igual e P que flutua.
E, como de costume, vamos
Para que você possa tomar este e agora podemos converter isso em um tensor de tocha em um voivode de tocha.
Então, faça isso, faça isso.
Bem, primeiro vamos converter isso em um sensor de tocha.
E lembre-se de que podemos usar torche que de não-prime que nós vamos e colocamos toda a matriz dos dois estados de
entrada dentro deste dançarino de tocha com a tocha deles por função perfeita que irá converter esses arrays dos dois
estados de entrada em uma tocha sensor.
a resposta em uma tocha muito bem usando a classe de variáveis, então a entrada será um objeto da classe valiosa.
E agora colocamos esta tocha
E na verdade, como você entendeu, essa classe de variáveis ​​leva tudo isso como argumento e isso
cria o objeto.
Tudo bem, então agora devemos ser bons.
Nós temos nossos dois insumos que precisamos.
Esse é o estado de entrada da primeira transição e, em seguida, a entrada diz que a última transição.
E agora, agora que temos as entradas Bem, o que podemos obter, podemos obter o sinal de saída do cérebro
da AI.
Essa é a predição de que vamos chamar saídas.
Esse é o sinal de saída.
E para obter as saídas.
Bem agora, isso é muito fácil porque já criamos um cérebro que é a nossa rede
neural convolutiva.
E assim podemos simplesmente levar o nosso cérebro CNN aplicado às entradas que irá retornar a previsão que é
o resultado tão simples quanto isso.
E agora já estamos prontos para avançar para o próximo passo.
E o próximo passo é começar a calcular esta comunidade se desejar.
Então, agora vamos fazer exatamente o mesmo que o nosso algoritmo como o Sarsour ou devemos
chamá-lo e passos para aprender.
Nós vamos apresentar a variável de recompensa cumulativa que será a recompensa cumulativa, vamos voltar ao artigo, como você pode
ver agora, o que temos a fazer para obter essa recompensa comunitária que é
nossa aqui.
atualizá-lo adicionando um zero a esta comunidade se estivéssemos se alcançássemos a última etapa da série ou o máximo
dos valores centrais se não alcançarmos a última etapa de A série é para todas as estaticas que duraram.
Bem e cada passo dos 10 passos correu, precisamos
Então, isso é simplesmente uma bonança.
Voltemos para Piscean.
Então, essa recompensa comunitária, como acabamos de ver, será igual a zero ponto zero se chegarmos ao último estado
e podemos escrever esta condição dessa maneira se uma série de índice menos 1.
Essa é a última transição da série.
definimos na experiência que jogamos nossa falta de repetição de experiência e isso é feito vem das
estruturas de abertura, porque se vamos ao site aberto da Allergan que é realmente correto Aqui eu preparei.
Então, adicionamos isso feito porque o fato é realmente um atributo de você conhecer esta estrutura de
transição que
Isso é bom ou vizir.
E se nós vamos à documentação e depois, se nós.
Esse é o tutorial que eu realmente incentivo você a dar uma olhada nisso.
Você pode executar um ambiente que Knowsley você pode ver que nossas observações de que estas
são transições são definidas por uma observação.
Queremos que isso seja feito aqui e isso significa exatamente que uma transição ou um passo acabou.
E então vamos usar isso feito aqui para nossa condição IF.
Portanto, a loucura iSeries quando isso significa se a última transição da série acabou.
E então, essa recompensa cumulativa será igual a zero se a última transição da série for feita.
Caso contrário, se não tivermos alcançado a última recompensa cumulativa bem sucedida, será atualizado com
o que dissemos o máximo de valores-chave.
E como essa saída é a saída do cérebro que é a previsão da rede neural.
E como você sabe, as previsões da rede neural são os valores previstos. Bem, esta saída
contém os valores.
E uma vez que precisamos ter o máximo de valores de q, precisamos adicionar primeiro esse
índice porque essa estrutura contém dois valores-chave e o próximo.
E então precisamos adicionar dados para acessar os dados.
Esta estrutura de saída que você conhece tem a estrutura especial de um voivode de tocha.
Então, com isso, obtemos nossos valores fundamentais e, em seguida, queremos tirar o máximo de nossos valores
de sugestão e, portanto, adicionamos esse Max.
E agora, obtemos exatamente o que queremos, como no papel, este máximo dos valores de cubo para
os estados não-terminais, como para aperfeiçoar.
E agora, o que vamos fazer é fazer a segunda dobra.
Isso é para as 10 etapas da série que vamos atualizar o cumulativo foi assim multiplicando primeiro por
Gamma o parâmetro de decaimento que já temos e depois adicionamos a palavra B.
Então vamos fazer isso.
Na verdade, vamos fazer exatamente o mesmo que no pseudocódigo, como você pode notar, eles começam
pela direita.
Então eles não estão começando com o primeiro passo e vão ao último teste que começam com o último passo.
T-menos 1 para o primeiro passo para começar.
Isso é exatamente o que vamos fazer e é por isso que
queremos chegar no final a recompensa cumulativa igual à nossa igual ou zero mais a gama ou 1 mais gama quadrada ou duas mais que adicionou
mais a gama no poder de 10 ou 10 onde são 1 ou 2 que são 10 são a palavra obtida em cada uma
das etapas da série.
Então, vamos dar uma pausa rápida antes de tomar o segundo ciclo completo e eu vou ver você no próximo tutorial.
Até então, desfrute da AI.