Olá e bem-vindo ao último passo desta primeira parte do edifício.
Agora, o único fato que temos de deixar é fazer com que a Ford funcione, que
irá propagar o sinal desde o início, quando o cérebro está conseguindo a imagem até o final quando
coloco a ação para que possamos fazer isso Toda a função e esse será o nosso
último passo antes de avançarmos para formar nossa IA com kulang convolucional profundo.
Então vamos fazer isso.
Vamos chamar a chamada de função que realmente é semelhante à função de init que é uma
função existente, mas desta vez a utilizamos para chamar algumas outras funções.
Os que fizemos antes, porque você sabe que vamos usar a função direta do
cérebro e a função portuária do corpo.
E então estamos usando essa função agora para basicamente chamar essas funções.
Então, a chamada vai levar dois argumentos.
O primeiro é o eu.
É claro que o objeto e o segundo argumento que, de acordo com você, será o que será.
Bem, estamos fazendo toda a propagação desta vez.
naturalmente, as imagens de entrada porque, claro, esse é o ponto de partida quando a AI está jogando o jogo.
Então, o que queremos tomar como entrada é,
Primeiro visualiza as imagens do jogo, depois propaga os sinais no cérebro e depois
toca a ação.
Portanto, o segundo argumento será insumos.
E agora estamos prontos para fazer toda essa propagação.
Então vamos fazer isso novamente.
Então, o primeiro passo onde é o primeiro passo é receber as imagens de entrada do jogo.
que temos que formatá-los em uma estrutura especial e a estrutura é, naturalmente, uma estrutura de tocha.
E uma vez que essas imagens vão entrar na rede neural. Bem, você pode imaginar
Então, a primeira coisa que acontecerá é que vamos converter essas imagens em uma matriz de árbitro,
então a converteremos em um tensor da tocha e, finalmente, vamos colocar o tensor da tocha dentro de uma variável de
tocha que conterá o tensor e um gradiente.
Isso é para os nossos gráficos dinâmicos para calcular de forma muito eficiente os gradientes mais tarde Kattie rápido,
no sentido.
Então esse é o nosso primeiro passo.
imagens, eles poderão entrar na rede neural e então é onde vamos fazer toda a propagação dos sinais.
E então, uma vez que possamos obter o formato certo de nossas
Então, vamos fazer isso primeiro, convertendo a imagem no formato certo.
Então, nossas imagens são tão para insumos.
Agora vamos criar uma nova variável que eu estou chamando de entrada.
Então, essa é a entrada real da rede neural e essa entrada.
Onde é que vai ser.
Bem, primeiro, precisamos tomar nossos insumos.
Estas são as nossas imagens originais.
Então, como dissemos, queremos converter essas imagens em arrays Nampa.
Então, para fazer isso, podemos simplesmente não tomar nenhum, pelo que tenha um atalho e, em seguida, a matriz de funções.
Então colocamos entre parênteses da matriz de funções.
Aqui vamos nós.
Agora é convertido em algo e por matrizes.
Mas então, uma vez que as células dos arrays numpad conterão os pixels, é realmente mais seguro
especificar o tipo flutuante.
É melhor ter certeza de que temos alguns carros alegóricos agora para garantir que possamos usar esse flutuador.
Desculpe por ouvir.
Tudo bem agora, ainda temos um árbitro.
Mas com o tablet.
Tudo bem e essa também é outra razão, é que os tensores são por definição arrays de um único tipo.
E então escolhemos o tipo único para ser um flutuador flutuante 32.
Tudo bem.
Agora que temos o nosso não-bio, o próximo passo é converter isso em um sensor de
tartaruga e, para isso, podemos usar, por exemplo, uma tocha.
E depois da função não-piloto de sublinhado que o converterá em um sensor de tocha.
Aqui vamos nós.
E agora o último passo é colocar esses sensores de tocha em uma variável de tocha contendo o tensor
e o acordo.
E você sabe como fazê-lo, é claro, nós levamos a nossa classe de variáveis ​​porque, na verdade, tudo que está dentro dessa
variável é realmente a entrada da classe de variáveis.
Mas eu queria mostrar isso para você dessa maneira porque você sabe que começamos com as nossas imagens de
entrada, então as convertemos em matrizes numeradas, depois para tensores de tocha e depois amanhã.
E agora estamos bons.
Eles são autorizados a entrar na rede neural que é primeiro os olhos do olho e, em seguida, as
camadas totalmente conectadas para levar a previsões.
Então, falando sobre os olhos dos olhos, é exatamente o que vamos fazer agora.
Nós vamos propagar essas imagens permitidas agora nos olhos dos olhos que são através das
três camadas convolucionais.
E para fazer isso, você vai ver agora como é tão simples.
Isso é porque já temos o nosso cérebro em nosso corpo a partir da função init.
Nós simplesmente precisamos levar nosso cérebro para o próprio cérebro e aplicar esse cérebro às imagens de entrada e isso irá propagar as
coisas para a função alimentar aqui do cérebro.
Isso irá propagar os sinais dentro do cérebro e uma vez que a função direta do
cérebro retorna os sinais de saída que os neurônios da camada de saída que contêm valores de Q. Bem,
essa entrada do cérebro aqui retornará esse sinal de saída e, portanto, vamos colocar aqui,
seja ele transformado em uma variável e vamos chamar isso simplesmente supera essa saída é o sinal de saída
do cérebro.
o corpo e, para isso, vamos usar a segunda função de avanço do corpo e fazer isso.
E agora, agora que temos o sinal de saída do cérebro. Bem, temos que propagar esse sinal de saída para
Nós simplesmente precisamos tomar nosso corpo e aplicá-lo, claro, a saída porque a função Ford do corpo
leva como entrada os sinais de saída do cérebro.
Então é exatamente o que é o resultado agora e retorna as ações.
E, portanto, desde que ele retorna as ações.
Bem, aqui vamos adicionar ações para causar a própria produção.
sinais dentro do cérebro e depois do cérebro até o primeiro, usando a função de forma do cérebro
que nos leva e coloca as imagens de entrada e depois as propaga no cérebro para mantenha os valores-chave.
Tudo bem, então agora você pode ver isso de forma muito simples, propagamos os
E então propagamos esse sinal de saída para o corpo onde a função direta do nosso corpo para
que a ação seja executada.
E agora, o único restante que temos que fazer e essa é a última linha de
código desta parte um construindo o.
Temos que devolver a ação para jogar e isso é ação.
ações têm que definir a tocha e precisamos convertê-las novamente por direito e, para isso,
vamos levar a estrutura de dados dessas ações e, em seguida, adicionar aqui a função não-piloto e depois vamos.
No entanto, no momento, as
Agora, temos as ações que viramos no formato correto.
Então, parabéns.
Agora terminamos com esta primeira parte 1.
Construímos a AI em três etapas.
Primeiro fizemos o cérebro em segundo lugar, nós fizemos o corpo.
E em terceiro lugar, montamos o cérebro no corpo e propagamos todo o sinal dos olhos até o momento
em que tocamos a ação.
Então, esse é um primeiro passo feito.
Esse foi um grande passo, mas agora, como você entendeu, construímos um AI AI, mas ainda é estúpido.
Precisamos treiná-lo para ser inteligente.
Então precisamos treiná-lo para fazer o que queríamos fazer e para fazer isso, vamos usar a
palavra para fazer ambientes que você conhece porque é aprender do mundo, sendo reforçada quando recebe uma
boa recompensa.
E ao ser punido ou enfraquecido quando está ficando uma palavra ruim, é aí que o aprendizado da sugestão
entrará em jogo.
E assim é exatamente o que faremos nesta parte para treinar nos olhos com o aprendizado Q convolucional profundo.
Não posso esperar para começar e até então eu.