Olá e bem vindo a este tutorial do Python.
Tudo bem.
Agora, na próxima função que estamos a implementar, iremos treinar a rede neural profunda que
está dentro da nossa inteligência artificial.
Então, basicamente, vamos fazer todo o processo de propagação e posterior propagação.
Então, é que vamos conseguir o nosso resultado.
Nós vamos conseguir o alvo.
calcular o último erro, então vamos voltar a propagar este último erro na nova rede.
Vamos comparar a saída do alvo para
E usando a descida gradiente sugerida que terá que esperar de acordo com o quanto eles contribuíram para
o último erro.
Então, vamos fazer tudo isso para aqueles que vêm do corpo de fuzileiros profundo.
Isso será bom, mas para os outros não se preocupe eu vou expandi-lo novamente.
Então, vamos chamar essa nova função para aprender e aprender a função vai levar vários argumentos.
Primeiro eu, claro, que se referirá ao objeto do grau em sala de aula.
em seguida, o nosso próximo estado do lote, em seguida, a nossa Essa recompensa e, finalmente, a ação de Arbat.
Então, iremos pegar o nosso estado em trânsito para o estado atual,
Então, por que tomamos isso.
Você provavelmente reconheceu o que é esta série.
Bem, é claro que é uma transição uma transição do processo de decisão do mercado que está na base.
Você aprendeu.
E por que todos os levamos para alguns lotes.
Bem, isso é porque você sabe, lembre-se que não consideramos as transições por uma série de recompensas
atuais de estado atual ou atual, e atual ação atual.
Criamos alguns lotes simples aqui graças à função simples.
E então agora nossas transições são na forma de primeiro lote para este estado.
Um segundo lote para a próxima data de um lote para a recompensa e um lote para a ação.
Essa é a forma de nossa transição agora e todos estão bem alinhados em relação
ao tempo, graças a essa concatenação que fizemos aqui em relação à primeira dimensão.
Então, o ponto é que agora temos essa transição de lotes um lote para cada um dos próximos dias, observamos
isso em ação e fazemos tudo isso porque estamos usando esse truque de repetição de experiência.
Então, a nossa rede neural profunda pode aprender alguma coisa.
Lembre-se se você só teve uma transição, por si só, o que seria uma aprendizagem instantânea.
Ou se você quer uma aprendizagem de memória muito curta e, portanto, a toupeira não aprenderia nada.
Então, temos que levar esses lotes da memória que se tornam nossas transições e, em seguida, teremos os resultados
diferentes para cada um dos estados dos estados de entrada e faremos isso para os estados
e para os próximos Estados porque precisaremos de ambos para calcular a perda.
Em breve, lembro a equação do equilíbrio que está no coração do algoritmo de aprendizagem.
Então, agora vamos entrar na função e primeiro obtenhamos as saídas do estado da caixa.
saídas viáveis ​​e então vamos dizer, claro, nossa auto-conversa, nem tudo são tão auto-iniciados.
Então, eu vou chamar essas primeiras
Não, porque queremos obter as saídas modelo dos estados de entrada do estado.
E como nosso modelo está realmente esperando um lote de estados de entrada.
Bem, podemos entrar completamente nesse estado agora para a entrada de todos eles.
É exatamente assim que inicializamos os estados que estão entrando na rede com respostas de torção com
esta vaga dimensão para o lote que é perfeita.
Agora recebemos os resultados de todos eles.
obteremos os resultados de todas as ações possíveis que você conhece 0 1 e 2, mas isso não é o que queremos.
Mas, em seguida, há outro truque técnico se apenas vendemos esse estado modelo bem,
Estamos apenas interessados ​​nas ações que foram escolhidas.
As ações que foram decididas pela rede para jogar em cada momento e, portanto, para que
essas pessoas realmente se interessem por isso são as ações jogadas bem, temos que usar essa função de reunião em
que inserimos uma porque só queremos a ação que foi escolhida e depois Nós adicionamos essa ação com essa.
E nessa seção, reuniremos cada vez que a melhor ação para jogar para cada um dos estados de
entrada do estado.
a ação que é jogada a ação que é escolhida e nós obtemos isso com isso reunir uma ação.
Nós não queremos
Mas então tenha cuidado.
O estado aqui tem esses diamantes falsos e graxa no lote e essa seção não o possui.
Backstay tem isso porque costumávamos usar o Unsworth aqui, mas não usamos nenhum aperto de braço para
as ações, então devemos adicioná-lo aqui para que a ação Bache tenha exatamente a mesma dimensão que o estado.
Então, vamos adicionar um ponto e apertar o seu direito aqui e, na verdade, isso não é zero, mas um porque a resposta
zero à Fé não é o estado e um corresponderá ao exame das ações.
E, finalmente, a última coisa que precisamos fazer aqui é que precisamos matar esse lote falso com um aperto.
Por que precisamos fazer isso.
Porque agora estamos fora da rede neural.
Nós temos nossos resultados, mas não os queremos de volta.
Nós os queremos.
E a resposta simples é um vetor simples.
Um vetor de saída dos lotes apenas quando trabalhamos na rede neural porque a rede
neural espera o formato dos sensores em um lote.
temos nossos resultados e na próxima equação de baluns da aprendizagem profunda, não precisaremos deles em um lote.
Mas agora nós
Então eu estou matando isso aqui e matando a dimensão de fé para recuperar a forma simples de nossos resultados.
Então, estou apenas adicionando aqui Dot e, em seguida, aperte e depois, porque eu quero matar a falsa laminação correspondente à
parte de trás da ação.
Bem, já que o motor do espaço-tempo possui um índice, eu estou adicionando um aqui.
Tudo bem.
E agora, nós vamos, nós temos nossos resultados.
ESTÁ BEM.
Temos um pequeno aviso sobre o que a saída da variável local é atribuída, mas nunca foi usada.
Isso está ok.
Nós vamos usá-lo muito rapidamente.
Então, essas são nossas saídas.
E agora queremos obter nossos próximos resultados Então agora você pode estar pensando por que precisamos dos próximos resultados.
Bem, para entender isso, precisamos voltar para o algoritmo de aprendizado profundo que está aqui mesmo
que faz parte do manual do letak.
Então, esse é todo o processo de difusão.
No início, inicializamos todos os valores-chave e, em seguida, em cada tempo t.
Bem, vamos lá, selecionamos a ação com Max suprimido, o que fizemos com a função de ação selecionada.
Então abrimos a transição e então, como você pode ver, obtemos a previsão de que obtemos o alvo e podemos
ser o último.
Então, por que precisamos da próxima saída também.
Isso é por causa do alvo que o alvo é igual a Gana, o próximo resultado mais o que queremos e
vamos calcular os alvos logo depois, pois precisamos do próximo resultado do alvo.
Vamos calcular isso primeiro.
Então, novamente para obter a próxima atualização muito simples, o próximo resultado será o resultado da
nossa rede neural quando o próximo estado em trânsito estiver entrando como entrada.
Então, simplesmente, nós tomamos nosso modelo que é a nossa rede neural e, desta vez, a entrada da
rede neural será o próximo estado em trânsito que se aproximou da próxima data.
Mas agora lembre-se se voltarmos ao algoritmo inicial. Bem, você pode ver que a próxima saída é o máximo dos valores
q para o próximo estado em relação a todas as ações.
Então, agora, para obter o próximo resultado, precisamos obter o máximo desses valores de q e, portanto,
vou fazer aqui.
Destaque você saber para separar todas as saídas do modelo porque temos vários estados neste lote nos próximos Estados que
são o lote de todos os estados seguintes em todas as transições tiradas da amostra aleatória
da nossa memória.
Então estou destacando todos eles usando a função de desbloqueio e depois estou levando o máximo de todos esses
dois valores.
E desde que estamos levando o máximo desses dois valores em relação à ação Bem, temos que
especificar que é em relação à ação.
E uma vez que a ação é representada pelo índice.
Bem, novamente, temos que colocar o próximo aqui e depois precisamos especificar que estamos levando os
valores de sugestão como T plus 1 que é o próximo estágio e o próximo estado é representado por 0
porque o índice zero corresponde aos estados e portanto, aqui precisamos adicionar colchetes com índice 0.
Dessa forma, obtemos o máximo dos valores-chave dos próximos estados representados pelo próximo zero de acordo
com todas as ações que são representadas pelo índice um e agora perfeitas obtemos as nossas próximas saídas.
Estes são um novo conjunto.
Foi quando tivemos o aviso.
Mas está tudo bem.
Vamos usá-lo agora para calcular o alvo.
E falando sobre o alvo, é o próximo passo dessa função conhecida.
Então vamos lá.
O alvo é igual.
Agora vamos voltar ao nosso manual AI AI.
O alvo é igual à palavra mais vezes de gama, a próxima saída é o máximo dos valores de cubo
do dia seguinte.
De acordo com as ações que podemos calcular.
Então, isso é igual a si mesmo que gamma e self que Gamma foi inicializado.
Aqui é introduzir uma que é uma variável da Virgem Q. Um objeto auto chegar aos tempos nas próximas saídas, como
acabamos de dizer mais. Queremos, essa é a melhor vontade.
Estamos trabalhando com lotes aqui, então, mais lote que queremos e esse é o alvo.
Em uma amostra da memória, a gama multiplicada pelas próximas saídas, além da recompensa.
Tudo bem.
Perfeito.
Então, agora temos nossos resultados.
Nós também temos nossos objetivos e, portanto, podemos calcular a perda da perda que representa o
erro da predição.
Então, vamos chamar isso de último, os dois últimos são, naturalmente, para a diferença temporal.
Isso é mais uma vez no coração de Q aprendendo e este tiddy nos vai ser igual ao lançamento que
melhora muito o Cunanan.
Essa é a última função que escolheremos para a nossa inteligência artificial.
Para aqueles que vêm do curso verde profundo, é realmente o último que eu recomendo.
Se você quiser implementar o Coonerty e então, como vamos conseguir isso.
Bem, novamente vamos tomar uma função a partir do módulo funcional representado por F
e, portanto, aqui vou usar nosso módulo funcional f pucks e o Hubble nós pode
ser obtido graças à função Smoots L-1 ama esse.
Então pressione Enter.
E essa é realmente a melhor função perdida que eu recomendo para aprender profundamente.
Realmente melhora o Culin.
Mas esta é uma função, então estou adicionando alguns parênteses.
E agora não há nada mais simples.
Os argumentos que precisamos inserir são as previsões e os objetivos.
Então, as previsões, é claro, são resultados porque essa é a saída da rede neural.
Não há saída da rede neural do que a rede neural predisse.
Então essa é a previsão.
Então, o primeiro argumento aqui é resultados e então o segundo argumento é, naturalmente, o alvo.
O que estamos tentando obter e já é calculado perfeito.
Nós podemos inserir diretamente o alvo.
Perfeito.
Agora nos disseram que temos um pouco de chá aqui.
Aqui vamos nós.
Agora, o aviso deve desaparecer.
Sim.
Perfeito.
E agora que temos o último erro, podemos voltar o erro dos propagadores de volta para a rede para
atualizar os pesos com descida gradiente estocástica e é exatamente isso que vamos fazer no próximo passo.
temos de fazer, como você pode imaginar, é adotar o nosso otimizador nosso otimizador, o que novamente nós apresentamos você inicializado.
Então, é claro, agora, o que
E isso é um otimizador de átomos que é realmente um objeto da classe Atom e já está equipado
com os parâmetros do nosso modelo.
E nós já escolhemos uma taxa de aprendizado de 0. 1 por cento para aperfeiçoar o nosso otimizador está pronto, mas
agora precisamos tocá-lo no último erro para executar grade estocástica no sentido e nos pesos de dados.
Então, ao trabalhar com lutadores, a primeira coisa que precisamos fazer é reinicializá-lo em cada iteração
do loop.
interação para o outro no loop deste para obter a grade no conjunto e reinicializá-lo.
Devemos reinicializar o otimizador de uma
E cada iteração do loop.
Bem, vamos usar o seguinte método, que é zero.
Aqui vamos nós.
O zero grad reinicializará o otimizador em cada iteração do loop.
Então não esqueçamos os parênteses.
Perfeito.
E agora que é reinicializado. Bem, podemos realizar propagação para trás com o nosso otimizador.
E como nós fazemos isso.
Bem, nós levamos nossas leis e vamos voltar a propagar de volta para a rede e
voltar propagado na rede.
Precisamos usar a função para trás e, dentro desta função para trás, recomendo inserir as variáveis
​​de sigla restante e configurá-la como verdadeira.
Eu recomendo fazer isso porque isso irá melhorar a propagação traseira.
O uso de variáveis ​​escritas igual a verdade é libertar alguma memória e precisamos
liberar a memória, porque vamos várias vezes no final, de modo que definitivamente o desempenho do treinamento melhorará.
E, finalmente, o último passo desta função aprendida é ter pesos de dados de acordo com a propagação traseira.
Isso é de acordo com o quanto os pesos contribuíram para o erro.
E para fazer isso, retomamos nosso otimizador, que foi inicializado na reinicialização e usamos a função de etapa e
simplesmente com esta linha de código usando a função de etapa.
Isso atualizará os pesos.
Essa é a linha de código que atualiza os pesos.
Esta linha de código que propaga o erro na rede neural e esta linha de código usa o otimizador
para atualizar os pesos e lá vamos.
Temos uma rede neural de aprendizado bem assim, parabéns.
Esta foi provavelmente a parte mais técnica e difícil de toda esta disputa ou amanhã.
Eu sei que minha tocha pode ser complicada às vezes com facilidade, espremer e espremer,
mas no final, eu prometo que você terá uma rede neural muito funcional e, portanto, modelo peculiar e, eventualmente,
uma grande inteligência artificial.
Então, vamos passar para o próximo passo ou professor e modelo, que será a função de atualização
que, obviamente, será atualizada quando o IA descobrirá o novo estado.
Então você sabe que vai descobrir o novo estado e depois receberá a recompensa.
Dependendo da ação que é exibida e este novo estado irá cuidar disso com a função
de atualização e fará isso no próximo tutorial.
Até então, aproveite.
EU.