Olá e seja bem vindo a este tubo e a Torro agora temos que definir as cinco variáveis ​​dessa
função que são as três convoluções e as conexões temporais.
Então vamos começar com o primeiro.
Convolucional aplica a convolução às imagens de entrada, de modo que são as imagens originais e agora você verá
como tudo se tornará tão simples para criar essa convolução.
Bem, o que temos que fazer é realmente criar um assunto de alguma classe específica e
esta classe é tirada de e, em seguida, as aulas vêm para o parceiro porque estamos trabalhando com imagens 2D e agora, como você pode
ver, precisamos colocar vários argumentos.
O primeiro está nos canais.
Vamos colocá-lo nos canais.
O segundo está fora dos canais.
O terceiro é o tamanho de Kerno e o resto deles é o preenchimento de passos dos grupos de dilatação e do viés.
E temos valores diferentes para todos esses.
Então, não vamos, mas eles vamos manter os valores padrão.
Mas o que é importante são esses três argumentos nos canais e canais e no tamanho do kernel e, portanto, eu adivinho
o que eles correspondem.
Bem, muito simplesmente, em geral, correspondem à entrada da convolução e todos os canais
correspondem à saída da conclusão.
Então, o que será?
Bem, muito simplesmente, esse será o número de canais em nossas imagens.
E na verdade, vamos trabalhar com imagens em preto e branco, porque basicamente não temos cores para
reconhecer os monstros.
A AI é totalmente capaz de reconhecer os monstros em preto e branco.
Então, não vemos as cores, apenas reconhecê-las por sua forma.
Portanto, vamos usar um canal para que um canal seja quando você tiver imagens em preto e branco
e três canais são quando você chamou imagens.
E, portanto, uma vez que estamos trabalhando com imagens em preto e
branco nos canais, será igual a um, então, nossos canais para que nossos canais sejam iguais às imagens que você deseja ter no
convolutivo lá, que é o resultado desta constituição 1.
E, basicamente, isso é igual ao número de recursos que deseja para o texto em suas imagens
originais, porque quem criará uma imagem por recurso que queremos detectar, porque basicamente você sabe como funciona.
de entrada e, portanto, o número de imagens de saída aqui é o número de recursos que queremos detectar.
Aplicamos um detector de recursos na imagem de entrada para detectar uma característica específica na imagem
Então, agora a questão é quantos recursos queremos detectar.
Bem, uma prática comum é começar com 32 detectores de recursos e assim nos levará a 32 por cento de imagens
nesta primeira camada convolucional para que a entrada seja uma imagem em preto e branco uma imagem real
e a saída na primeira convolução existe 32 imagens processadas e por processo, quero dizer, claro, que
a conclusão foi aplicada à imagem de entrada para obter 32 novas imagens com recursos detectados.
E então precisamos especificar um tamanho de kernel que não seja mais do que as dimensões do quadrado
que irão passar pela imagem original.
E, em prática comum, usamos para comprar dois ou três três ou três por cinco.
E para o primeiro, vamos usar um detector de recursos cinco por cinco que é um detector de
recursos que terá cinco a cinco motores.
E então reduziremos o tamanho desse kernel para as próximas camadas convolutivas.
E falando sobre isso, é exatamente o que vamos fazer agora.
Vamos copiar isso para definir a segunda convolução e, portanto, estou baseando que aqui e agora é muito engraçado e
muito fácil é como um dominó.
canal de entrada da segunda camada convolucional é o canal de saída da primeira convolução.
O
Então, este número de saída 32 Aqui está o mesmo número de entradas 32 aqui.
E é porque temos 32 imagens na camada convolucional de entrada da segunda convolução.
E então a segunda convolução é aplicada a esta segunda camada convolucional para retornar uma terceira camada
convolucional.
E agora a questão é quantas imagens novas queremos.
Bem, o mesmo que cria 32 novas imagens 32 é realmente um número muito comum em redes neurais convolutivas,
se você olhar para as arquiteturas, você encontrará 32 em muitos deles.
E, em seguida, para o tamanho do kernel, nós precisamos reduzir o tamanho do kernel que são as dimensões do nosso
detector de recursos.
E agora vamos passar de cinco a quatro ou até três e depois iremos ainda menores.
Tudo bem, então nossa segunda convolução está pronta.
Demora como entradas 32 imagens do processo.
Cada um em uma primeira característica da imagem de entrada original e cria 32 novas imagens.
Graças a estas dimensões reduzidas do detector de recursos.
E agora vamos empurrar isso ainda mais.
Então eu estou copiando isso e colando isso aqui para criar uma terceira convolução para detectar alguns recursos.
E então agora é o mesmo os canais de entrada.
Aqui está o número de imagens de entrada à esquerda da conexão de deconvolução e esse é o número
de imagens de précessão que foram à direita das conexões de convolução anteriores.
Isso é 32.
Por isso, sentimos a pena ouvir.
Perfeito.
E agora a questão é de novo quantas novas imagens queremos detectar.
Vamos levar agora 64 e, portanto, 64 saídas precesso de imagens.
E é claro que agora nós tomamos um tamanho de kernel menor e nós vamos levar dois.
E assim é uma arquitetura muito clássica de um convolucional lá e é muito eficiente ter um
alto nível de detecção de recursos dentro de imagens.
Tudo bem e agora que temos nossos três convolucionais, há nossas três conexões de convolução
aqui.
todas as 64 vezes 32 vezes 32 novamente imagens que obtivemos de todas essas convoluções, então nós aplainamos
todos os pixels dessas imagens e podemos um enorme vetor que se tornará a entrada de uma nova rede neural totalmente conectada.
Bem, agora é hora de obter nossas conexões dolorosas que eu lembro que vamos levar este
enorme vetor que obtemos depois de achatar
E então é quando temos que fazer essas conexões entre o primeiro vetor enorme e uma camada oculta e,
em seguida, uma segunda conexão completa entre a camada oculta e a saída, eles são compostos pelos neurônios
de saída.
Cada um correspondente a um valor de cubo das possíveis ações.
Então, vamos fazer essas duas conexões.
Você sabe como fazer isso.
Isso é exatamente o que fizemos para o carro auto-dirigido.
Então vamos fazer isso de novo.
Bem, primeiro nós levamos o nosso Maggio, então nós levamos o Lynnie nossa classe porque novamente a conexão que criamos
é um objeto da classe dominante.
E então entre parênteses.
Bem, isso é o mesmo para colocar os recursos de entrada que é o número deles, então os recursos de saída.
E, portanto, os recursos de entrada para a primeira conexão completa, o que será.
que há nesta grande mudança de vetor depois de achatar todas as imagens do processo após as três convoluções.
Bem, isso vai ser igual ao número de pixels
E então, o que faz esse número.
Bem, na verdade, há um truque aqui.
Este número é realmente difícil de obter.
Na verdade, precisamos fazer uma função para calcular esse número.
Não temos uma variável que nos obtenha esse número.
Nós temos que computá-lo e, portanto, o que vamos fazer agora.
porque a primeira vez que você pode dizer oi, eu não Tenha esse número de neurônios no vetor Flaten.
E agora é muito importante entender a mentalidade da programação que devemos ter e tentar trazer para você a
mentalidade que é o que você deve estar pensando agora para fazer para superar esse obstáculo
O que devo fazer.
Estou preso aqui.
Bem, não, na verdade, porque o que você pode fazer agora é simplesmente inserir qualquer nome aqui que represente o número
de neurônios tão incomum que o número de neurônios número de neurônios e então simplesmente criaremos
uma função que retornará e esse número de neurônios variará.
Este número de pixels que procuramos.
Então, podemos fazer totalmente que podemos colocar totalmente isso muito vocal, é claro, obteremos um aviso
porque ele ainda não existe, mas vamos criá-lo depois com uma função.
E estamos totalmente autorizados a fazer isso, mesmo que a função venha depois.
Essa é uma programação típica que você deve ter quando obtém esse tipo de obstáculo.
Bem, você pode fazer uma função para obter o que está faltando.
Tudo bem e depois nossas características e nosso futuro.
Esse é o número de neurônios em uma camada oculta e que esta vez depende de você.
Isso depende da arquitetura da nova rede que deseja criar.
E assim um bom número não seria um pequeno número.
Então, por exemplo, 40 neurônios podem estar bem.
Podemos tentar aumentar isso.
Se o treinamento não for muito lento, você pode tentar aumentar isso.
Talvez isso melhore as previsões, mas vamos começar com 40 talvez possamos aumentar isso depois.
Tudo bem é para a primeira conexão completa, então copiaremos essa pasta que aqui para a segunda conexão completa que
é a conexão entre a camada oculta e a camada de saída.
E assim, os recursos aqui se tornam os recursos externos da camada anterior e isso é 40.
Então, aqui podemos colocar 40.
É claro que é o número de neurônios em uma camada.
E nosso futuro será igual ao número de neurônios de saída, não deve haver rede neural.
E uma vez que cada neurônio de saída corresponde a um novo valor e um Cuvee e
resposta a uma ação enquanto o número de neurônios de saída aqui é, naturalmente, o
número de ações e temos uma variável para isso, que é ações numéricas e, portanto, aqui as ações do número de entrada e vamos parabéns.
Encontrámos a arquitetura da nossa rede neural, a nossa rede neural é composta por três camadas
convolutivas e uma camada oculta.
Tudo isso em uma grande CNN e esta CNN detectará recursos no jogo para que a AI saiba onde ele
tem que fazer onde deve ir e onde precisa disparar.
Então, vamos para este passo.
Esse é um primeiro passo muito importante feito.
Agora, vamos passar para o próximo passo, que é, naturalmente, para obter esse número de neurônios que
ainda está faltando.
Na verdade, é por isso que temos o aviso aqui e os neurônios do número de telefone, mas sem preocupações.
neste enorme vetor e vamos colocar esse número em uma variável que irá chamar uma série de neurônios.
Agora vamos fazer uma função que irá retornar o número de neurônios
Então vamos fazer isso no próximo tutorial.
Esse é o nosso próximo passo.
E até então, desfrute da AI.