Olá e seja bem vindo a este tutorial do Python no Statoil, vamos dar o primeiro passo na implementação
do modelo de teoria profunda.
Então, basicamente, estamos prestes a implementar todo o processo do algoritmo de difusão.
E então vamos usar o que criamos antes.
Essa é a arquitetura da rede neural para reproduzir a memória para integrar isso no
processo de aprendizagem inteiro.
E todo esse algoritmo de aprendizagem vai se encaixar em uma única classe.
Esse é o último que estamos fazendo para implementar a inteligência artificial.
E esta classe apenas irá conter funções diferentes.
Então, teremos as funções que criarão e inicializarão todas as variáveis ​​associadas aos
nossos futuros objetos de desvio que representarão o próprio modelo e terão outras funções.
Um deles, obviamente, será selecionar a ação certa em cada momento.
Também teremos uma função de função de atualização para obter esse núcleo e ter uma idéia de como a aprendizagem
está indo se estiver indo bem.
Se a exploração está indo bem e se pode passar para a exploração e então teremos uma função segura
para economizar amanhã, que é para salvar o cérebro do carro e, em seguida, carregar a função.
Então, temos algumas funções para fazer.
Vamos fazer uma função para cada trabalho.
E hoje vamos começar com a função final, como de costume, quando estamos fazendo uma aula.
Mas primeiro não se esqueça de apresentar a aula, então vamos chamá-la de D.
Q E para você rede, em seguida, alguns parênteses chamam.
E então vamos com nossa primeira função.
Então, vamos fazer isso, então, sublinhado duplo, então o sublinhado duplo novamente e os parênteses.
Então, como você entendeu nesta função, vamos apresentar as variáveis ​​anexadas ao nosso objeto.
Então, vamos ter um par de linhas começando por si só e basicamente criaremos
e inicializaremos todas as variáveis ​​necessárias para implementar a rede D2.
Então, vamos, por exemplo, criar um objeto ou rede porque, é claro, precisamos da nossa rede neural profunda,
então precisaremos da nossa memória.
Vamos criar outra variável para a memória.
Então, teremos outra variável de memória autônoma, mas isso não é tudo o que teremos que criar também.
Algumas variáveis ​​para a última data.
A última ação e a última palavra.
É claro que você conhece as variáveis ​​que você vê no algoritmo de difusão.
E então, o que mais.
Bem, também precisamos de um otimizador que você conheça para executar grade estocástica no sentido dos pesos de
dados de acordo com o quanto eles contribuirão com o erro.
Quando a AI está cometendo um erro e então acho que, basicamente, as variáveis ​​que agora
precisamos criar e inicializar.
Mas nessa função init, colocaremos um par de argumentos primeiro como auto usual, que são os argumentos
referentes ao nosso objeto.
Então, como você sabe, vamos criar um objeto da classe de rede.
Bem, uma vez que a classe de rede toma como argumento no tamanho da entrada da função init e na ação Bem, isso é
o mesmo aqui.
Ao criar um objeto da classe de rede, precisaremos escolher um argumento de tamanho de entrada e
o argumento atual.
Portanto, podemos copiá-los aqui
e aqui vamos.
Então, esses argumentos agora se tornarão.
Também alguns argumentos não duraram.
Sempre que criamos alguns objetos futuros da classe diferente que alguns modelos voltados para o futuro. Bem, precisamos especificar
o tamanho de entrada que eu lembro é o número de dimensões nos vetores que
estão incluindo seus estados.
Os seus estados de entrada e uma série de ações que é o número de possíveis ações que o carro pode fazer.
Então eu lembro para você.
Estes são ou vão para a esquerda, vá direto ou vá para a direita.
Ok, perfeito.
Então você sabe que você estará criando um novo objeto da classe de memória de repetição para
criar o objeto de memória para obter nossa memória das transições e na informação que temos o argumento de capacidade.
Mas uma vez que só vamos usá-lo uma vez, na verdade, quando criamos memória e não a
partir de então, não precisamos especificar o argumento da capacidade.
Poderíamos fazer isso, mas entraremos diretamente no número de transições que queremos que nossa memória tenha.
Mas, então, precisamos de um último argumento para obter o parâmetro no modelo do professor.
Lembre-se que este parâmetro gama é o atraso.
parâmetro da equação e, portanto, vamos colocá-lo aqui porque vamos usá-lo depois várias vezes.
E esse é um
Então, vamos colocá-lo aqui.
Nós vamos chamá-lo Gamma.
Então, para isso é apenas o nome do argumento e, em seguida, vamos todos os argumentos que você precisará para
isso em sua função.
Isso significa que sempre que criamos nosso modelo de dicionário que é sempre que criamos um objeto do professor em
sala de aula.
Bem, precisamos especificar como argumentos o tamanho da entrada o número de ação e o parâmetro.
E acabaremos com os valores reais para eles.
Tudo bem, então, vamos dentro da função.
ESTÁ BEM.
Então agora basicamente isso vai ser fácil.
Estamos prestes a criar e inicializar todas as variáveis ​​que precisamos.
E então vamos começar com o primeiro.
Vamos começar com a gama.
Na verdade, o coeficiente de atraso.
Então, como este é um Voivode quer ser anexado ao seu objeto, começamos com o eu.
Então, gamma vai ser uma variável do nosso professor e do próprio modelo, que gama é igual aos argumentos que
serão dados ao criar um objeto da classe detune.
Então, Janna e aí vamos com o segundo argumento.
O segundo argumento será a janela de recompensa.
Então, qual é essa janela?
da média das últimas 100 palavras que você usará apenas para avaliar a evolução da performance
que você conhece terá o significado da palavra nesta guerra Windu que irá deslizar ao longo do tempo.
Bem, essa será a janela deslizante
E o que queremos observar é o significado das últimas 100 palavras aumentando com o tempo.
Então, vamos iniciá-lo com a auto-estima que a janela de sublinhado de recompensa.
E assim, uma vez que esta será uma janela deslizante do significado crescente das últimas 100 palavras.
Bem, vamos iniciá-lo como uma lista vazia e então expandiremos para significar que trabalhamos horas extras.
Tudo bem, então, mais emocionante.
Vamos criar nossa rede neural.
Então, vamos chamar de Mario autodidata porque basicamente esse é o coração dos modelos.
Eu estou chamando de modelo e esse modelo não será mais que um assunto nessa classe e
criará esse objeto.
Nós levamos nossa rede de classe entre parênteses e aqui nós apenas colocamos os argumentos da classe, mas colocamos esses
argumentos nos argumentos da função de inicialização e, portanto, precisamos copiá-los aqui e apenas
colá-los na classe de rede e então nós vá com esta linha de código.
Criamos uma rede neural para aprender modelo perfeito então vamos criar uma memória.
Então, novamente, vamos criar um novo Vargo que chamamos de memória autodidata.
E novamente isso vai ser um objeto da classe de memória de repetição.
Então, vamos apenas pegar o nome ou a classe, vamos copiar ainda vamos enfrentar isso aqui e, em alguns parênteses, precisamos
colocar a capacidade porque a capacidade é um argumento da função e esse é o único argumento
que precisamos aqui.
Então, qual a capacidade que vamos escolher, lembre-se que corresponde ao número de transições o número
de eventos último estado em que você declara a última ação e a última palavra.
E, assim como mencionado em um dos problemas do Priester, vamos levar cem mil cem mil transições para
a memória e então amostraremos a partir desta memória para obter um pequeno número de transições
aleatórias e aquela em que o modelo será OK.
Então, agora temos nossa memória perfeita.
Agora vamos buscar o nosso otimizador.
Então, novamente, nós criamos uma nova variável que chamamos otimizador, então otimizador é outra variável do nosso
futuro dequeue, um objeto que o otimizador.
E agora, se voltarmos para cima, você pode ver que importámos o Upton torturado, que é uma tocha modular que contém todas
as ferramentas para realizar a grade no centro.
otimizadores e nós lhe demos o atalho Upton e, portanto, aqui o que vamos fazer é levar o modelo
até ele, que é tocha que ele e a partir deste módulo, vamos levar um dos otimizadores.
Então, é claro, ele contém alguns
Então, como você pode ver, eles estão todos listados aqui.
Muitos deles são excelentes, por exemplo, o Propp da armadura é um excelente otimizador.
Existe, por exemplo, altamente recomendado para registro de redes neurais ou aprendizagem profunda sem supervisão.
Mas o outro que é excelente e que ele escolherá é o otimizador de átomos.
Esse é o que você verá que com este receberá um bom carro auto-dirigido.
Mas, novamente, você é bem-vindo para tentar outros, você pode tentar os braços, mas, para o metal,
escolheremos o Adam.
Então estou pressionando Enter.
E na verdade você notará que há o Capitólio aqui.
Isso porque estamos criando um objeto da classe Atom.
Esta é uma classe, mas o objeto será um otimizador de átomos em si.
Mas uma vez que esta é uma classe, precisamos colocar alguns argumentos, os argumentos da classe Atom e
os argumentos são todos os parâmetros que podem personalizar o seu otimizador.
Então, por exemplo, é tipicamente a taxa de aprendizagem a decadência ou alguns outros parâmetros.
E, além de tomar todos os parâmetros de Ormeau, especificaremos uma taxa de aprendizado.
Então, está começando os parâmetros do nosso modelo.
Podemos obtê-los com um modelo de dúvida de si.
Então, esse é o modelo que criamos aqui modelo autodidacta de nossa própria classe.
Então modelo autodidacta e, em seguida, para acessar os parâmetros do modelo, adicionamos outro ponto e, em seguida,
parâmetros com alguns parênteses, muito simplesmente.
Então, é só conectar o otimizador addon à nossa rede neural que criamos aqui novamente, como acabamos
de mencionar, vamos adicionar uma taxa de aprendizado e o argumento para isso é nosso.
que a aprendizagem não aconteça muito rápido se obtivermos uma taxa de aprendizado muito grande, então a AI AI aprenderá corretamente.
E vamos configurá-lo igual a um valor, de modo
Queremos dar a nossa AI algum tempo para explorar aprender com seus erros.
Você sabe quando nós puni-lo quando está cometendo alguns erros como entrar em algum sentido ou chegar muito
perto de um muro.
Bem, queremos dar algum tempo para aprender.
Queremos que uma maneira para a rede neural até o momento corretamente.
E, portanto, um bom valor para a taxa de aprendizado que acabei depois de tentar vários deles é 0. 2 ou um.
Tudo bem e é tudo o que precisamos para criar um otimizador.
Então, basicamente, você está criando um objeto da classe Atom.
Ótimo.
E então as últimas três variáveis ​​que precisamos são as variáveis ​​que compõem nossos eventos de transição.
Então essa é a última data da última ação e a última palavra.
E então é basicamente o que vamos criar agora e só precisaremos inicializá-los.
Então vamos começar com a última data da última data em que a chamaremos de autodidataçao.
O último estado de sublinhado e, em seguida, como você vai inicializar.
que a última data é um vetor de 5 dominações, um vetor codificado em um estado do meio ambiente.
Bem, lembre-se
E, como lembrete, estas cinco dimensões são os três sinais dos três sensores
que ficam retos e diretos e orientações e menos orientação.
Então, este é um vetor e um sentido intuitivo.
Mas por tocha precisa ser mais do que um vetor.
Na verdade, ele precisa ser um tensor da tocha.
Mas não só precisa ser um sensor de tocha, mas também precisa ter mais uma dimensão que eu
gosto de chamar de dimensão falsa que corresponde ao lote.
E isso ocorre porque os últimos oito serão a entrada da rede neural, mas quando trabalhar comigo quando isso
funciona em geral, seja com um fluxo mais denso, carrega uma tocha, enquanto os vetores de entrada não podem ser
um vetor simples por si só.
Tem que estar em um lote.
A rede só pode aceitar o lote de observações de entrada e, portanto, não só irá criar um
tensor para vetores de estado de entrada, mas também criaremos essa dimensão falsa correspondente ao lote.
Então, vamos fazer isso e vamos começar por inicializar um tensor da tocha para que isso não seja nada
mais simples.
Nós levamos a nossa biblioteca de torche, em seguida, e então vamos usar a classe do tensor porque, como você pode ter
adivinhado, isso criará um objeto da classe do tensor que é um objeto tensor.
E neste tensor precisamos colocar um argumento que especifique o tamanho do tensor.
Você pode imaginar que leva você como uma matriz com um único tipo.
Mas, basicamente, o que isso representará agora é, é claro, esse estado de entrada que você pode ver tem um vetor e,
portanto, especificar o número de elementos que a distância deve ter.
Bem, precisamos usar, é claro, o tamanho da entrada porque o tamanho da entrada é exatamente o número de dimensões
de nossos vetores de estado de entrada.
Agora devo dizer tensores.
E então, o que simplesmente precisamos inserir na nossa classe de tensores para criar um objeto tensor.
Bem, isso é impreciso.
E mais tarde, o tamanho da entrada será quantificado.
Tudo bem, isso é bom.
Essa é a primeira coisa feita.
Acabamos de inicializar o tensor como deveria ser.
que você Coloque no lote será a primeira vez que eu mencionei isso, digamos muito bem.
Mas então lembre-se de que precisamos fazer outra coisa, precisamos criar essa dimensão falsa, porque isso é o que a rede
esperará por suas insumos e criará essa para exame que, de propósito, deve ser o motor da
primeira vez, você conhece o dano
Bem, para fazer isso, simplesmente precisamos adicionar isso e espremer e, em alguns parênteses.
Precisamos colocar o índice dessa grande dimensão.
E, como acabei de dizer, essa dimensão falsa tem que ser a primeira animação da última data e, desde
índices e bytes e início zero, precisamos inserir zero para que este novo mecanismo de paradigma esteja se tornando o primeiro
motor de linha.
Então, temos um motor de primeira vez correspondente ao lote e, em seguida, o diamante deve responder
a esse sensor que conterá os cinco elementos de seus estados de entrada a orientação de três sinais e
menos orientação.
E então, nós iniciamos nossos estados de entrada corretamente.
Perfeito.
E, em seguida, duas variáveis ​​para ir e isso vai ser muito mais fácil porque a próxima variável é a
última ação.
Esse é um novo Roybal que estamos criando para a última ação do objeto.
E lembre-se no primeiro tutorial da seção que eu disse que as ações serão 0
1 ou 2 e, em seguida, usando o vetor de rotação de ação, converteremos esses índices dessas ações nos ângulos
da rotação que eu lembro ao nosso 0 20 ou menos 20.
Podemos realmente atualizar nossa memória com isso.
Bem, é exatamente aqui.
Ação para rotação se a ação for zero.
Bem, isto corresponderá ao primeiro índice de zero se a ação for 1.
20 graus, que será o ângulo de rotação de nosso carro quando tocarmos a ação.
Isso corresponderá ao índice um desses vetores de 20 graus e, se a ação for, obteremos menos
Tudo bem.
E, portanto, uma vez que a ação vai ser 0 1 ou 2 Bem, a ação está lá para um
número simples.
E muito simplesmente podemos inicializá-lo para zero.
Não precisamos criar dezenas nem ouvir nada mais.
Nós precisamos inicializar com zero.
E finalmente.
Bem, essa é a última palavra.
É o eu que última palavra.
Aqui vamos nós.
E novamente a palavra é um número flutuante que eu lembro é entre menos 1 e mais 1.
Então esse é o número novamente.
E quanto à ação.
Vamos inicializá-lo para zero e depois vamos.
Parabéns estão na função está pronta.
Então, agora estamos prontos para seguir as coisas interessantes.
E, na verdade, a coisa mais importante para a IA que está decidindo qual a ação a desempenhar em cada
momento e cada tanty. E é exatamente isso que vamos fazer no próximo tutorial criando o método de ação selecionado.
Então vamos fazer isso no próximo ao trabalho e até então eu.