Olá e bem vindo a este tutorial do Python.
Tudo bem, então temos muito emocionante para o solo à nossa frente.
Vamos começar criando a arquitetura da rede neural que será a rede neural
que estará no coração da nossa AI e que irá retornar a ação aos 90 anos.
Então vamos fazer isso.
Então, como queremos que a nossa rede neural seja objetiva, vamos fazer uma aula.
E é porque é muito mais conveniente.
Você sabe que a classe é o modelo de algo que queremos construir.
Queremos construir uma rede neural e precisamos fazer algum tipo de instruções que serão todas
contidas na classe.
E nesta classe vamos fazer duas funções.
Primeiro, a função de init que é a função que surge o tempo todo ao fazer a classe.
E isso basicamente define a variável do seu objeto que é a rede neural.
Você conhece as variáveis ​​anexadas ao objeto em oposição às variáveis ​​globais.
definirá a arquitetura da nova rede que você conhece definindo a camada de entrada que será
composta de cinco neurônios de entrada porque temos cinco dimensões para o vetor codificado de estados de entrada.
E isso é nesta função que
Então vamos definir algumas camadas ocultas.
Talvez você comece com uma camada oculta e então você será bem-vindo para tentar algumas outras arquiteturas
da rede neural.
E, claro, acabaremos com a camada de saída que conterá as possíveis ações que
podemos desempenhar em cada momento.
Então é exatamente isso que faremos nesta função.
a função direta e essa será a função que ativará os neurônios na rede neural.
E então faremos outra função ainda dentro da classe, que será
Você sabe que isso ativará os sinais e, portanto, usaremos uma função de ativação rectificada
porque, claro, estamos lidando com um problema puramente não linear e essa função corrigida quebra a linearidade.
Mas, principalmente, estamos fazendo essa função da Ford para retornar os valores de q que são as saídas da rede.
Mas temos um valor-chave para cada ação.
E mais tarde, retornaremos a ação final tomando o máximo dos valores-chave ou usando um
método Max suave.
Veremos isso depois.
Então, neste tutorial, vamos começar por implementar a função de inicialização e, em seguida,
a próxima será implementar a função de avanço.
Então vamos fazer isso.
Primeiro, precisamos apresentar nossa classe.
Então começamos com a aula e nós damos um nome à nossa classe, onde é onde podemos chamá-la de rede.
E então, nesta classe de rede, vou usar uma técnica de programação de objetos que é chamada de
herança e que é apenas herdar de todas as ferramentas de uma classe pai.
Portanto, nossa classe de rede que estamos prestes a fazer é um teste infantil de uma classe maior que é.
E esse módulo.
Então, é apenas para herdar de todas as ferramentas desta classe de módulo, que, claro, as ferramentas para implementar
uma rede neural.
Então, esse é um truque muito poderoso e evolutivo na programação orientada a objetos que está indo na herança.
E agora nós estamos herdando deste módulo classe pai.
Tudo bem e agora estamos prontos para entrar na classe.
Então, estou pressionando Enter duas vezes na verdade, porque estaremos fazendo duas funções e estamos começando com
a função final.
Então, a função init, devemos nomeá-lo dessa maneira com dois neste curso, então nela.
E, novamente, ressalta que é apenas a sintaxe de Python que é exatamente como devemos fazê-lo.
E então precisamos colocar os argumentos.
Então, temos três argumentos.
O primeiro é um argumento obrigatório que é realmente eu e eu.
Não há nenhum mistério sobre isso que se refere ao objeto que será criado a partir desta classe que estamos prestes
a fazer.
Você sabe que estamos fazendo essa aula.
É como algumas instruções algum modelo dessa rede neural que queremos construir.
E então, uma vez que a aula está pronta, podemos fazer a maioria das redes com as quais desejamos.
E cada uma dessas novas redes será algum objeto desta classe e, uma vez que estaremos usando
o objeto para outros fins, precisamos, mas quais são as variáveis ​​do objeto e para Spudis estamos usando este
eu aqui para especificar que nós está se referindo ao objeto.
Então, sempre que eu quiser usar disponível no meu objeto, usarei o self antes da variável para
especificar que esta é uma variável do objeto.
são, naturalmente, o número de neurônios de entrada e o número de neurônios de saída.
Tudo bem, então esse é o primeiro argumento e depois temos dois outros argumentos que
Então, o número de neurônios de entrada que vamos chamar de tamanho de entrada e na verdade é
cinco porque nossos vetores de entrada têm cinco dimensões para três sinais mais orientação mais orientação negativa
que são vetores de valores codificados que descrevem um estado do ambiente.
Estes cinco valores são suficientes para descrever o estado do meio ambiente.
Poderíamos ter pensado em Menos valores ou mais valores, mas isso é o que eu tentei e realmente faz
sentido porque realmente precisamos de um sinal da esquerda na nossa frente e um à direita.
orientação de orientação e menos para você Saiba como acompanhar o objetivo que você estava tentando alcançar.
Você sabe quando estamos dirigindo um carro, poderíamos ter ido para um sinal de 360 ​​que você conhece como os sinais no
topo dos carros do Google, que podemos auto-conduzir totalmente com três sensores e, então, temos essa
E então temos, claro, os neurônios de saída da nossa rede que correspondem às ações e temos
três ações possíveis indo indo direto ou indo direto.
E, portanto, vou chamar isso e a ação e haverá três deles.
Tudo bem.
Até agora, só temos que dar nomes às insumos e depois usaremos estes vôlei para fazer as condições
dentro da rede neural.
Tudo bem então e você começa usando outro por torção, esse truque é uma superfunção que
é uma função que realmente herda do módulo.
Então, por isso, tivemos que usar a herança para herdar o módulo também.
Este é o primeiro a usar.
E, basicamente, estamos usando apenas esta superfunção super super para poder usar as ferramentas do módulo que
são muito mais eficientes.
E dentro da superfunção eu só preciso especificar primeiro a rede.
de chul de rede que você conhece, porque isso é herdar da classe pai do módulo e, em seguida, o nosso objeto.
Então, essa é a nossa classe
E então eu apenas estou adicionando isso e está em uma função como essa, exatamente como o chamamos.
Tudo bem, então é apenas um truque que é apenas usar todas as ferramentas que tenho.
E nesse módulo, podemos passar para o próximo passo, que é especificar a camada de entrada.
Então, basicamente, o que devo fazer é introduzir uma nova variável que será anexada ao objeto e
esta variável conterá o número de neurônios de entrada.
Portanto, não deve ser confundido com tamanho de entrada tamanho de entrada é o argumento da função final.
não é a variável que está anexada ao objeto, mas a variável que está anexada ao objeto.
Mas essa
Bem, como acabei de mencionar, precisamos especificar que é em vez disso anexado ao objeto, então usamos
uma autodidata e agora damos um nome a esta primeira variável anexada ao objeto.
E assim podemos simplesmente dar o mesmo nome que a entrada.
Podemos chamá-lo de tamanho de entrada e diremos que é igual aos argumentos uma função que é tamanho de entrada.
Tudo bem.
Cada vez que estou criando um objeto da classe de rede e estou especificando o tamanho da entrada, como por
exemplo, estou colocando 5.
Haverá 5 aqui e, portanto, a variável de tamanho de entrada do nosso objeto terá o valor de
5, pois esse tamanho de entrada será 5 e, portanto, nossa nova rede terá 5 neurônios de entrada
na camada de entrada.
Tudo bem.
E então é o mesmo para a outra variável que queremos anexar aos objetos.
E, como você pode ter adivinado, esta será uma variável para o número de neurônios de saída.
E para dizer que tomamos nosso objeto e depois damos um nome a esta segunda variável do
objeto que vamos chamar e a ação.
E isso será igual a este argumento aqui, dado o número de ações que é o número de neurônios
de saída.
E então, estabelecemos igual a ação efetivamente e a ação será igual a três.
Portanto, a variável e a ação anexada ao nosso objeto a uma rede obterão o valor de três.
Na verdade, podemos ver avisando aqui que ele diz um nome indefinido.
E então, bem, é porque aqui usamos o.
E, em seguida, atalho.
E precisamos usar um atalho aqui.
E para o nosso início torche e em Mudgal e então ele irá desaparecer.
Aqui vamos nós.
Perfeito.
Agora, temos novas advertências, todas as advertências aqui são apenas para especificar que o que importamos ainda não
é usado.
Isso está certo, vamos usá-los depois.
Tudo bem, então, temos outras duas variáveis ​​que queremos definir para o objeto.
as conexões completas das conexões completas entre as diferentes camadas da nossa rede neural.
E estas serão
Então, agora mesmo queremos criar uma rede neural composta de apenas uma cabeça em seu
mundo, haverá duas conexões completas.
Haverá uma primeira conexão completa entre a camada de entrada e a camada oculta.
E um segundo conexão completa entre a colina e a camada de saída.
Então vamos começar com a primeira conexão completa.
Vamos chamá-lo de SE1 E, novamente, uso-me aqui para especificar que o FC é uma variável do meu objeto para
resolver isso.
FC um que será igual a.
E agora usamos o módulo N in e vamos usar uma função chamada R linear e é exatamente
essa conexão completa entre os neurônios e a camada de entrada para os neurônios do escondido.
E o que quero dizer com uma conexão completa.
Isso significa que todos os neurônios da camada de entrada estarão todos conectados a todos os neurônios
do Here aqui.
E assim, para fazer essa conexão, usamos essa função linear à qual precisamos colocar alguns argumentos.
E como você pode ver esses argumentos estão em recursos.
Então, esse é o número de neurônios da primeira lei que você deseja conectar-se a recursos que é o
número de neurônios da segunda camada que deseja conectar, que é a camada à direita que é
a camada oculta e a bicicleta é verdadeira.
Então, a bicicleta é verdade, manteremos o valor padrão que é para ter um viés e não apenas um pouco
de peso ligado à execução, teremos que esperar e um viés para cada camada.
E tão bem, vamos ver o que precisamos para entrar.
Portanto, o primeiro argumento em características é o número de neurônios de entrada na camada de entrada.
E então, onde está.
Bem, isso é realmente impreciso.
Esse é o argumento da nossa função de init que mais tarde poderemos combater a orientação dos três sinais
e a orientação de Mannus.
Aqui vamos nos.
Quando os primeiros argumentos e colocar o tamanho e, em seguida, o segundo argumento são recursos que é o número de
neurônios que queremos ter na segunda camada.
A segunda camada que estará totalmente conectada à primeira camada.
E agora a questão é quantos neurônios queremos nesta camada oculta.
Bem, fiz muito treinamento de parâmetros.
Eu fiz muitas experiências.
Isso é o que fazemos ou é o que fazemos em profundidade.
Em geral, fazemos muita experiência para ver qual seria a melhor rede neural para o nosso
problema específico.
E então eu tento muitos valores e acabei escolhendo 30 30 execuções em uma camada oculta e você verá que com
este número obtemos alguns resultados muito bons, mas então sinta-se livre para mudar a arquitetura
da rede neural.
Sinta-se livre para jogar com ele.
Você não pode apenas mudar o número de neurônios aqui e ali, mas também pode adicionar mais camadas
para que você consiga um carro ainda melhor, mas 30 neurônios hinna nos obterão uma boa rede neural e
uma boa causa.
Então, é por isso que buscamos.
E nós vamos lá.
Temos nossa primeira conexão completa realmente com essa função linear.
Fazemos a conexão entre a camada de entrada e a perna escondida.
E agora é hora de fazer a segunda conexão completa, que é a conexão completa entre a camada oculta
e a camada de saída.
Então vamos lá.
Vamos ligar para esta segunda conexão completa no C2.
Aqui vamos nós.
E ainda está disponível para mais objetos usando o Saphir.
E, novamente, nós usamos.
Bem, na verdade, podemos copiar isso porque vamos usar o módulo N no módulo e, em seguida, a função linear.
Mas então precisamos mudar os argumentos, é claro, primeiro.
Esse é o mesmo primeiro é o número de neurônios que vamos ter na primeira camada da conexão.
Então, isso é oculto lá.
E, portanto, isso é 30 e, em seguida, segundo argumento é o número de neurônios na segunda camada da
conexão e que corresponde à camada de saída e a saída que tem.
E os neurônios reais que mais tarde serão três porque temos três ações possíveis, mas até agora temos
que usar os nomes que definimos.
o nome do argumento da função init e, portanto, nós inserimos aqui e a ação e aí vamos.
Esse é
Em primeiro lugar, nossas conexões de tupla re.
E em segundo lugar, todas as funções são Israel.
Então, é isso que vamos inicializar o nosso objeto sempre que criamos um objeto da classe de rede.
E então, assim que criamos um objeto bem, todas essas variáveis ​​para variáveis ​​aqui tamanho de entrada e reação.
Você e dois serão definidos.
E é assim que obteremos a arquitetura da nossa rede animal para cada objeto que criamos.
corresponderá a uma rede neural de cinco neurônios de entrada 30 neurônios escondidos e três neurônios de saída.
Cada objeto
Então vamos lá.
Terminamos com esta primeira função e agora podemos avançar para a segunda função que é a
função direta e que será usada para ativar os neurônios na rede neural usando a função de ativação
do retificador e principalmente para retornar aos valores do cubo que são as saídas de uma única rede.
Então eu não posso esperar para fazer isso no próximo tutorial e até então eu.