Atividade sobre Redes Neurais

Prévia do material em texto

FACULDADE SAPIENS 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
REDES NEURAIS 
 
Flaviano Silva |Ximenes 
Diony da Silva 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
PORTO VELHO, 2019 
 
 
INTRODUÇÃO 
 
 
Não é de hoje que computação tenta reproduzir atividades do cérebro humano, e 
pensando nisso foi idealizado o conceito de Redes Neurais, que são sistemas de 
computação entrelaçados que visam simular o funcionamento do cérebro humano. 
 
 
Usando algoritmos, esse mecanismo pode interpretar padrões, correlacionar dados, 
agrupá-los e ir além, “aprendendo” e se auto melhorando. 
 
 
Aqui veremos alguns conceitos, exemplos e outras abordagens deste interessante 
tema que está tão presente no dia-a-dia e muitas vezes não é percebido. 
 
As redes neurais têm sido utilizadas para solucionar diversos problemas de 
engenharia como, por exemplo, em processamento digital de imagens, robótica e 
processamento digital de sinais. 
Redes neurais artificiais são técnicas computacionais que utilizam como modelo o 
funcionamento do cérebro humano, onde os neurônios são treinados de forma a 
responder somente aos padrões de entrada, podendo ser utilizadas no 
reconhecimento de padrões sem a necessidade de um treinamento prévio. 
As principais características que tornam desejáveis o estudo e o uso das redes 
neurais artificiais são: a capacidade das mesmas de aprender através da 
experiência, a capacidade de se adaptar a situações adversas e a sua tolerância a 
ruídos. 
 
 
 
 
 
Rede Neurais 
 
Você já se perguntou como funcionam os sistemas de reconhecimento de imagem? 
Como um aplicativo do seu celular faz para detectar rostos, ou um teclado 
inteligente sugere a próxima palavra? As chamadas Redes Neurais tem sido 
amplamente usadas para tarefas como essas, mas mostraram-se úteis também em 
outras áreas, como aproximação de funções, previsão de séries temporais e 
processamento de linguagem natural. 
Neste artigo, explico como funciona um tipo básico de Rede Neural, o Perceptron 
Multicamadas , e um fascinante algoritmo responsável pelo aprendizado da rede, o 
backpropagation . Tal modelo de rede serviu de base para os modelos mais 
complexos hoje existentes, como as Redes Convolucionais, que são o estado da 
arte para classificação de imagens. 
Se você estudou Cálculo na universidade e ainda não se esqueceu, não terá 
dificuldade em entender a parte do texto que está escrita em Matematiquês… Caso 
contrário, não se sinta incomodado pelas fórmulas, apenas foque na ideia principal; 
algumas analogias ao mundo real que procurei estabelecer irão ajudá-lo a entender 
também. 
1. Modelo computacional de um neurônio 
Inspirando-se no funcionamento dos neurônios biológicos do sistema nervoso dos 
animais, estabeleceu-se na área da Inteligência Artificial um modelo computacional 
de um neurônio conforme ilustrado a seguir: 
 
Modelo computacional de um neurônio. 
Os sinais da entrada no neurônio são representados pelo vetor x = [ x1, x2, x3, …, 
xN ], podendo corresponder aos pixels de uma imagem, por exemplo. Ao chegarem 
ao neurônio, são multiplicados pelos respectivos pesos sinápticos, que são os 
elementos do vetor w = [ w1, w2, w3, …, wN ], gerando o valor z , comumente 
denominado potencial de ativação, de acordo com a expressão: 
 
O termo adicional b provê um grau de liberdade a mais, que não é afetado pela 
entrada nessa expressão, correspondendo tipicamente ao “ bias” (viés) . O valor z 
passa então por uma função matemática de ativação σ, com a característica de ser 
não linear, responsável por limitar tal valor a um certo intervalo, produzindo o valor 
final de saída y do neurônio. Algumas funções de ativação usadas são 
a degrau, sigmóide, tangente hiperbólica, softmax e ReLU ( Rectified Linear Unit ). 
2. Combinando neurônios em camadas 
Com apenas um neurônio não se pode fazer muita coisa, mas podemos combiná-los 
em uma estrutura em camadas, cada uma com número diferente de neurônios, 
formando uma rede neural denominada Perceptron Multicamadas (“ Multi Layer 
Perceptron   —  MLP ” ). O vetor de valores de entrada x passa pela camada inicial, 
cujos valores de saída são ligados às entradas da camada seguinte, e assim por 
diante, até a rede fornecer como resultado os valores de saída da última camada. 
Pode-se arranjar a rede em várias camadas, tornando-a profunda e capaz de 
aprender relações cada vez mais complexas. 
 
Neurônios combinados formando um rede. Cada círculo representa um neurônio 
como aquele descrito anteriormente. 
3. Treinamento de um MLP 
Para que uma rede dessas funcione, é preciso treiná-la. É como ensinar a uma 
criança o beabá. O treinamento de uma rede MLP insere-se no contexto de 
aprendizado de máquina supervisionado, em que cada amostra de dados utilizada 
apresenta um rótulo informando a que classificação ela se encaixa. Por exemplo, 
uma imagem de um cachorro contém um rótulo informando que aquilo é um 
cachorro. Assim, a ideia geral é fazer com que a rede aprenda os padrões 
referentes a cada tipo de coisa (cada classe ), assim, quando uma amostra 
desconhecida for fornecida à rede, ela seja capaz de estabelecer a qual classe tal 
amostra pertence. Como isso pode ser feito? 
Backpropagation 
“Não é errando que se aprende?” 
A ideia do algoritmo backpropagation é, com base no cálculo do erro ocorrido na 
camada de saída da rede neural, recalcular o valor dos pesos do vetor w da camada 
última camada de neurônios e assim proceder para as camadas anteriores, de trás 
para a frente, ou seja, atualizar todos os pesos w das camadas a partir da última até 
atingir a camada de entrada da rede, para isso realizando a retropropagação o erro 
obtido pela rede. Em outras palavras, calcula-se o erro entre o que a rede achou 
que era e o que de fato era (era um gato e ela achou que era um cachorro — temos 
aí um erro!), então recalculamos o valor de todos os pesos, começando da última 
camada e indo até a primeira, sempre tendo em vista diminuir esse erro. 
Traduzindo essa ideia para o matematiquês , o backpropagation consiste nas 
seguintes etapas: 
● Inicializar todos os pesos da rede com pequenos valores aleatórios . 
● Fornecer dados de entrada à rede e calcular o valor da função de erro 
obtida, ao comparar com o valor de saída esperado. Lembre-se de que 
como o aprendizado é supervisionado, já se sabe de antemão qual 
deveria ser a resposta correta. É importante que a função de erro seja 
diferenciável . 
● Na tentativa de minimizar o valor da função de erro, calculam-se os 
valores dos gradientes para cada peso da rede. Do Cálculo , sabemos 
que o vetor gradiente fornece a direção de maior crescimento de uma 
função; aqui, como queremos caminhar com os pesos na direção de 
maior decréscimo da função de erro, basta tomarmos o sentido contrário 
ao do gradiente e…voilà! Já temos um excelente caminho por onde 
andar. 
● Uma vez que temos o vetor gradiente calculado, atualizamos cada peso 
de modo iterativo , sempre recalculando os gradientes em cada passo de 
iteração, até o erro diminuir e chegar abaixo de algum limiar 
preestabelecido, ou o número de iterações atingir um valor máximo, 
quando enfim o algoritmo termina e a rede está treinada. 
Assim, a fórmula geral de atualização dos pesos na iteração fica: 
 
Fórmula geral de atualização dos pesos da rede neural 
Ou seja, o valor do peso na iteração atual será o valor do peso na iteração anterior, 
corrigido de valor proporcional ao gradiente. O sinal negativo indica que estamos 
indo na direção contrária à do gradiente, conforme mencionado. O parâmetro η 
representa a taxa de aprendizado da rede neural,controlando a tamanho do passo 
que tomamos na correção do peso. 
Fazendo uma analogia, imagine que você está numa região montanhosa e escura, 
desejando descer o mais rápido possível à procura de um vale, na esperança de 
encontrar um lago de águas límpidas. É possível andar em várias direções, mas 
você tenta achar a melhor ao sentir o solo ao redor e tomar aquela com maior 
declive. Em termos matemáticos, você está indo na direção contrária à do vetor 
gradiente. Considere também que você pode controlar o tamanho do passo que 
pode dar, mas note que passos muito largos podem fazê-lo passar do vale, caindo 
na outra montanha mais adiante, e outro passo largo o trará de volta à primeira 
montanha, fazendo-o pular pra lá e pra cá sem nunca alcançar o vale; por outro 
lado, passos muito curtos o farão demorar muito a descer, podendo morrer de sede 
do meio do caminho. 
Voltando ao matematiquês , o conceito-chave da equação anterior é o cálculo da 
expressão ∂E /∂w, consistindo em computar as derivadas parciais da função de 
erro E em relação a cada peso do vetor w . Para nosso auxílio, vamos considerar a 
figura a seguir, que ilustra uma rede MLP com duas camadas e servirá de base para 
a explicação do backpropagation. Uma conexão entre um neurônio j e um neurônio i 
da camada seguinte possui peso w[j,i] . Repare que os números sobrescritos, entre 
parênteses, indicam o número da camada à qual a variável em questão pertence, 
podendo, neste exemplo, valer (1) ou (2). 
 
Rede MLP para ilustrar a explicação do backpropagation. Os pesos dos neurônios 
inferiores foram omitidos para não tornar a figura visualmente poluída. 
Sinta-se à vontade para voltar à figura anterior conforme for acompanhando os 
passos a seguir. Sendo y a saída esperada e ŷ a saída obtida pela rede, definimos a 
função de erro como sendo: 
 
Ou seja, aqui estamos simplesmente calculando a somatória dos quadrados das 
diferenças entre os elementos dos dois vetores. Agora, calculamos a derivada 
parcial do erro em relação à camada de saída, ŷ: 
 
Seguindo a estrutura da rede para a esquerda, prosseguimos no cálculo da derivada 
do erro em relação ao potencial de ativação z da camada (2), usando a Regra da 
Cadeia . 
 
Note que σ′ é a derivada da função de ativação do neurônio. Por exemplo, no caso 
de ser a função sigmoide, sua derivada vale σ′(z) = σ (z)( 1 − σ (z)). 
Este valor é o gradiente local em relação ao i- ésimo neurônio da camada (2) e, para 
não tornar as fórmulas excessivamente extensas, será simplesmente indicado como 
δ : 
 
Finalmente, usando a Regra da Cadeia mais uma vez, computamos a derivada 
parcial do erro em função de um peso w[j,i] da camada (2): 
 
O cálculo em relação ao bias é análogo, resultando em: 
 
Com esses resultados em mãos, é possível aplicar a fórmula geral de atualização 
dos pesos dos neurônios da última camada: 
 
E a fórmula de atualização do bias: 
 
Pronto, já temos a fórmula mágica para atualizar os pesos dos neurônios da última 
camada. Agora temos que calcular esta expressão para os pesos dos neurônios da 
camada anterior; logo, precisamos calcular a derivada parcial em relação à saída 
y[i] da camada (1). A sacada aqui é perceber que tal valor y[i] interfere em todos os 
neurônios da camada seguinte, assim, temos que considerar a somatória dos erros 
que ele propaga: 
 
Mas: 
 
Resultando em: 
 
Prosseguindo, temos: 
 
Esse δ a que igualamos o resultado segue a mesma ideia anterior: é o gradiente 
local em relação ao i- ésimo neurônio da camada (1). Finalmente, vem: 
 
Substituindo na fórmula de atualização dos pesos: 
 
Novamente, as fórmulas para o bias são análogas e ficam como exercício. 
É isso! Caso existissem mais camadas na rede, o procedimento continuaria, 
seguindo sempre esse mesmo padrão de calcular as derivadas parciais, 
retropropagando os erros até a camada de entrada da rede. 
O backpropagation é um algoritmo elegante e engenhoso. Os atuais modelos deep 
learning como Redes Neurais Convolucionais, embora mais refinados que o MLP, 
têm se mostrado muito superiores em tarefas como classificação de imagens e 
também utilizam como método de aprendizado o backpropagation, assim como as 
chamadas Redes Neurais Recorrentes, em processamento de linguagem natural, 
também fazem uso desse algoritmo. O mais incrível é que tais modelos conseguem 
encontrar padrões inobserváveis e obscuros para nós, humanos, o que é fascinante 
e permite considerar que em breve estaremos contando com a ajuda do deep 
learning para resolver muitos dos principais problemas que afligem a humanidade, 
como a cura do câncer. 
 
 
 
Redes Neurais Artificiais são técnicas computacionais que apresentam um modelo 
matemático inspirado na estrutura neural de organismos inteligentes e que adquirem 
conhecimento através da experiência. Uma grande rede neural artificial pode ter 
centenas ou milhares de unidades de processamento; já o cérebro de um mamífero 
pode ter muitos bilhões de neurônios. 
 
 
 
 
Os neurônios são formados pelos dendritos, que são um conjunto de terminais de 
entrada, pelo corpo central, e pelos axônios que são longos terminais de saída. 
 
 
A propriedade mais importante das redes neurais é a habilidade de aprender de seu 
ambiente e com isso melhorar seu desempenho. Isso é feito através de um 
processo iterativo de ajustes aplicado a seus pesos, o treinamento. O aprendizado 
ocorre quando a rede neural atinge uma solução generalizada para uma classe de 
problemas. 
 
 
O perceptron é um algoritmo de aprendizado de classificadores binário. 
 
Já o O perceptron multicamadas (MLP) é uma rede neural semelhante ao 
perceptron simples, porém possui mais de uma camada de neurônios. 
 
 
O método do gradiente (ou método do máximo declive) é um método numérico 
usado em otimização. Para encontrar um mínimo (local) de uma função usa-se um 
esquema iterativo, onde em cada passo se toma a direção (negativa) do gradiente, 
que corresponde à direção de declive máximo. 
 
 
 
O propósito do passo para frente é propagar nossas entradas (os dados de entrada) 
através da rede aplicando uma série de dot products (multiplicação entre os vetores) 
e ativações até chegarmos à camada de saída da rede (ou seja, nossas previsões). 
 
O backpropagation é indiscutivelmente o algoritmo mais importante na história das 
redes neurais – sem backpropagation (eficiente), seria impossível treinar redes de 
aprendizagem profunda da forma que vemos hoje. 
 
 
O perceptron multicamadas (MLP) é uma rede neural semelhante ao perceptron 
simples, porém possui mais de uma camada de neurônios. Em casos em que não 
há a possibilidade de uma única reta separar os elementos, há o uso da MLP que, 
gera mais de uma reta classificadora. 
 
 
Função de desvios de erros, O algoritmo de retropropagação de erro, é um 
algoritmo utilizado no treinamento de redes neurais multicamadas, e consiste em 
dois passos de computação: o processamento direto e o processamento reverso. 
 
 
Como os erros são importantes para as redes neurais e como é a fórmula para 
calcular os erros? 
 
É muito importante a máquina errar, pois ela literalmente aprende com os erros, 
tornando se cada vez melhor. 
 
A fórmula usada: ( Novo Peso = Peso Antigo – Derivada * Taxa de Aprendizagem). 
 
 
 
 Operadores AND e OR e XOR com relação ao PMC 
 
 
AND: Operador lógico no qual a resposta da operação é verdade (1) se ambas as 
variáveis de entrada forem verdade. 
 
 
OR: Operador lógico no qual a resposta da operação é verdade (1) se pelo menos 
uma das variáveis de entrada for verdade. 
 
 
XOR: Operador lógico no qual a resposta da operação é verdade(1) quando as 
variáveis assumem valores diferentes entre si. 
 
 
VOCÊ JÁ OUVIU FALAR DE ESTIMATOR? 
 
Esta não é uma palavra com uma definição rigorosa, mas geralmente associada a 
encontrar um valor atual nos dados. Se não contássemos explicitamente a mudança 
em nosso bolso, poderíamos usar uma estimativa. 
 
AQUI AS ETAPAS DE UMA CLASSIFICAÇÃO SUPERVISIONADA COM PMC 
 
Aproximação universal de funções, classificação de padrões, identificação e controle 
de processos, previsão de séries e temporadas e otimização de sistemas. 
 
 
 
 
 
Rede Neural com keras 
 
Keras é uma biblioteca de rede neural de código aberto escrita em Python. É capaz 
de funcionar com o Tensor Flow, o Microsoft Cognitive Toolkit, o Theano ou o Plaid 
ML. Projetado para permitir a experimentação rápida com redes neurais profundas, 
ele se concentra em ser fácil de usar, modular e extensível. 
 
Rede Neural com keras 
Como estou estudando continuamente esse mundo, decidi transformar meus 
estudos em artigos de anotações. É mais ou menos como estudar em grupo; o tema 
é lançado e cada um contribui com seu pouco. Meu pouco hoje é sobre a 
construção de uma rede Neural com keras (uma simples). 
O que é Keras 
Keras é uma biblioteca para rede neural de alto-nível escrita em Python e roda como 
frontend em TensorFlow ou Theano. O bacana disso é que você pode substituir uma 
rede neural por outra utilizando Keras. Ela foi desenvolvida para facilitar 
experimentações rápidas, isto é, sem que você tenha que dominar cada um dos 
backgrounds, de maneira rápida e eficiente. 
A curta e clara descrição está na página inicial do site do projeto nesse link . A 
biblioteca é aplicável nas seguintes condições: 
● Prototipagem rápida e fácil (total modularidade, minimalismo e 
extensibilidade). 
● Suporte a redes convolucionais e recorrentes, incluindo combinação de 
ambas. 
● Suporte a esquemas de conectividade arbitrária (incluindo treino de N para 
N). 
● Rodar na CPU ou GPU. 
Aplicabilidade 
De que adianta tanta teoria sem aplicação? É o que normalmente acontece na 
escola no primeiro e segundo grau, onde a galera não tem muito incentivo pra 
gostar de matemática porque não é aplicada. Bem, um dos principais temas do meu 
site é embarcados e tudo o que escrevo deve ser relacionado. Estou com um robô 
quadrúpede aqui para escrever artigo e pretendo colocar ao menos um pouco de 
visão computacional nele e para reconhecimento facial, vou utilizar remotamente o 
Open Face (desse outro artigo). Devagar vou aplicando em diversas arquiteturas, 
incluindo Arduino (com o processamento remoto, claro), mas acompanhe os artigos 
precedentes, apenas como uma leitura de apreciação, caso não queira executar 
nenhum dos exercícios. 
Testes iniciais dos tutoriais de deep learning 
Alguns tutoriais virão de estudo das respectivas documentações, outros de tutoriais 
modificados e outros, de livros. Os de livros sempre são mais elaborados e cheios 
de minúcias, mas farei com que sejam breves e claros o suficiente, baseado no meu 
entendimento (que poderá ocasionalmente conter enganos). 
Instalação 
 
 
No tutorial anterior mostrei a instalação do Tensor Flow utilizando o virtualenv. Siga 
o tutorial como primeiro passo e depois incremente a instalação com os próximos 
passos. Se você já tem o virtualenv com o Tensor Flow do artigo anterior, então 
inicie o ambiente virtual para seguir: 
1 source ~/tensorflow/bin/activate 
Se você digitar ‘pip search keras’ dentro do virtualenv, é capaz de você querer 
instalar tudo, mas vamos por partes: 
1 pip install Keras learning ml scipy 
Essa instalação auto-incluirá o Theano, não se assuste. 
Os 6 passos finais 
Após a instalação, os 6 passos finais são totalmente relacionados ao código, mas se 
olhar de um modo geral, esse é o último passo. No tutorial que encontrei para fazer 
o primeiro teste o processo está descrito de forma similar. 
Gerar semente e carregar os dados 
Essa parte do processo auxiliará a obter os mesmos resultados toda a vez que rodar 
os testes, de modo que você poderá demonstrar os resultados ou debugar. Isso se 
resume a 1 única linha, mas como é o começo do código, tem os cabeçalhos e tal: 
1 
2 
3 
4 
5 
from keras.models import Sequential 
from keras.layers import Dense 
import numpy 
 
numpy.random.seed(7) 
Esse tutorial que me baseei utiliza um conjunto de dados de 5 anos de estudo de 
diabetes hereditária ( esse aqui ) feito com meninas de 21 anos de idade. A 
classificação é binária, onde diabetes é 1 e a negativa é 0. Acredito que a escolha 
tenha se baseado nesse fato pela facilidade de redirecionar esses dados para a 
rede neural. Baixe o conjunto de dados e coloque-o em seu diretório de trabalho, 
juntamente ao arquivo de código que estamos escrevendo. 
1 
2 
wget -c 
http://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes
/pima-indians-diabetes.data 
mv pima-indians-diabetes.data pima-indians-diabetes.csv 
O arquivo será carregado completamente para a memória e então manipulado. 
Nesse ponto você já deve ter percebido que para um largo número de dados será 
necessária uma quantidade vasta de memória, exceto suas manipulações adotem 
outro meio. Para esse tutorial, não teremos problemas com esse conjunto de dados. 
As próximas linhas de código dividem o conjunto de dados em entradas e saídas (X 
e Y, respectivamente): 
1 dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",") 
2 
3 
X = dataset[:,0:8] 
Y = dataset[:,8] 
Definição do modelo de dados 
Os modelos em Keras são definidos como uma sequência de camadas. Ainda 
entraremos em detalhes sobre modelos e classificadores em outro artigo, por ora 
vamos manter o foco no tutorial. Isto facilita a criação do modelo, bastando inserir 
uma camada por vez até que estejamos satisfeitos com a topologia da rede. Tudo 
ficará mais claro, apenas acompanhe a leitura para assimilar as ideias e assim 
podermos em breve construir algo para embarcados. 
A primeira coisa a se fazer é garantir que a camada de entrada tem o número 
correto de inputs. Isto pode ser especificado enquanto criando a primeira camada 
com o argumento ‘input dim’, atribuindo-lhe 8, para o variáveis de entrada. 
Existe uma questão muito difícil a considerar, que é o número de camadas e seus 
tipos. O método heurístico certamente é uma grande opção para encontrar a melhor 
estrutura de rede, mas o problema é que você precisará de tempo para aprender a 
fazer tunnings. Por exemplo, quando iniciei minhas pesquisas em reconhecimento 
facial, passei por uma série complexa de experimentação até que (graças a Deus) 
iniciei experimentos com o OpenFace. Apesar de ser uma caixa de mágicas, levou 
praticamente um mês até que eu compreendesse alguns níveis importantes dessa 
estrutura para então chegar a 100% de confiabilidade em uma base de 40 pessoas. 
Conforme a base aumenta, a confidência diminui, mas nada mal chegar a 100% em 
uma base de treinamento com poucos minutos de sua criação. 
No exemplo que peguei com Keras, a estrutura de rede é fully-connected com 3 
camadas. Isto é, todos osneurônios se comunicam antes da saída. 
Nós podemos especificar o número de neurônios na camada como primeiro 
argumento, o método de inicialização como segundo argumento sendo ‘init’ e 
especificar a função de ativação utilizando o argumento ‘activation’. 
Neste caso, nós inicializamos o peso da rede para um pequeno número randômico 
gerado a partir de uma distribuição uniforme (‘uniform’), entre 0 e 0.05, nesse caso, 
porque esse é o peso padrão da distribuição uniforme no Keras. Uma alternativa 
tradicional seria o ‘normal’, gerando assim pequenos números randômicos a partir 
de uma distribuição gaussiana. 
Também será usada a função retificadora ‘relu’ nas primeiras duas camadas e a 
função sigmoide na camada de saída. O resultado deverá ser algo entre 0 e 1 com 
um threshold padrão de 0.5. 
Enfim, montando o código, você pode notar que a primeira camada tem 12 
neurôniose espera 8 variáveis de entrada. A segunda camada possui 8 neurônios e 
finalmente a saída tem 1 neurônio fazendo a predição da classe alvo (início de 
diabetes ou não). 
1 
2 
3 
4 
model = Sequential() 
model.add(Dense(12, input_dim=8, init='uniform', activation='relu')) 
model.add(Dense(8, init='uniform', activation='relu')) 
model.add(Dense(1, init='uniform', activation='sigmoid')) 
Compilação do modelo 
A compilação do mdelo usa uma eficiente biblioteca numérica de backend, como 
Theano or TensorFlow. O backend automaticamente escolhe o melhor caminho para 
representar a rede e fazer predições. 
Será necessário em algum momento especificar a função de per para avaliar os 
pesos. Nesse exemplo foi definido o uso da função de perda logarítmica, definido 
em Keras como “binary_crossentropy”. Também é utilizado o algorítmo gradiente de 
descida ‘adam’. Repare que diversos nomes foram utilizados nos últimos 
parágrafos. Essas são as maiores dificuldades para iniciar-se em redes neurais e 
visão computacional, porque é necessário ter ao menos uma noção do que se trata, 
para poder posteriormente aplicá-las conforme a necessidade surgir. Eu estou 
baseando-me em um post de terceiro (em inglês, referenciado ao final do artigo) 
para ter o primeiro contato e a partir daí, aprender de uma forma mais suave. Isso 
significa que você não encontrará fórmulas prontas para todas as suas 
necessidades, mas você deverá sim criar suas próprias “receitas”. Ocasionalmente, 
alguns padrões podem trazer resultados satisfatórios. 
1 model.compile(loss='binary_crossentropy', optimizer='adam', 
metrics=['accuracy']) 
Ajuste ou treino 
 
 
Nós podemos fazer essa tarefa com o método ‘.fit()’ do modelo para ajustar o 
número de iterações, utilizando o argumento nb_epoch. Por fim, com ‘batch_size’ 
ajustamos o número de instâncias. Esses valores podem ser ajustados por tentativa 
e erro: 
1 model.fit(X, Y, nb_epoch=150, batch_size=10) 
Avaliando o modelo 
O treinamento da rede neural foi feita sobre o conjunto completo de dados e a 
performance da rede neural pode ser avaliada no mesmo conjunto de dados, o que 
nos dará uma boa ideia do quão bem modelada foi a rede. Mais que óbvio, 
utiliza-se a função evaluate() no modelo, passando o mesmo núermo de inputs e 
outputs usados no treinamento. Isto gerará uma predição para cada entrada e saída 
e coletará pontuação, incluindo média de perda e qualquer métrica que tenha sido 
configurada, como a acurácia. 
1 
2 
scores = model.evaluate(X, Y) 
print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100)) 
Atando os nós 
O tutorial no qual me baseei mostrou o quão fácil pode ser modelar uma rede neural 
com Keras (claro que isso não significa que sua rede neural será supimpa sem os 
devidos ajustes e experimentações). Colocando todo o código junto, o resultado é 
isso: 
1 
2 
3 
4 
5 
6 
7 
8 
9 
1
0 
11 
1
2 
1
3 
1
4 
1
5 
1
6 
1
7 
1
8 
1
9 
2
0 
# Create first network with Keras 
from keras.models import Sequential 
from keras.layers import Dense 
import numpy 
# fix random seed for reproducibility 
seed = 7 
numpy.random.seed(seed) 
# load pima indians dataset 
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",") 
# split into input (X) and output (Y) variables 
X = dataset[:,0:8] 
Y = dataset[:,8] 
# create model 
model = Sequential() 
model.add(Dense(12, input_dim=8, init='uniform', activation='relu')) 
model.add(Dense(8, init='uniform', activation='relu')) 
model.add(Dense(1, init='uniform', activation='sigmoid')) 
# Compile model 
model.compile(loss='binary_crossentropy', optimizer='adam', 
metrics=['accuracy']) 
# Fit the model 
model.fit(X, Y, nb_epoch=150, batch_size=10) 
# evaluate the model 
scores = model.evaluate(X, Y) 
print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100)) 
2
1 
2
2 
2
3 
2
4 
São 24 linhas, incluindo os comentários! 
Utilizando o modelo em um novo conjunto de dados 
O tutorial no qual me baseei adicionou mais duas linhas de código para gerar novas 
previsões, resultando nesse código: 
1 
2 
3 
4 
5 
6 
7 
8 
9 
1
0 
11 
1
2 
1
3 
1
4 
# Create first network with Keras 
from keras.models import Sequential 
from keras.layers import Dense 
import numpy 
# fix random seed for reproducibility 
seed = 7 
numpy.random.seed(seed) 
# load pima indians dataset 
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",") 
# split into input (X) and output (Y) variables 
X = dataset[:,0:8] 
Y = dataset[:,8] 
# create model 
model = Sequential() 
model.add(Dense(12, input_dim=8, init='uniform', activation='relu')) 
model.add(Dense(8, init='uniform', activation='relu')) 
1
5 
1
6 
1
7 
1
8 
1
9 
2
0 
2
1 
2
2 
2
3 
2
4 
2
5 
2
6 
model.add(Dense(1, init='uniform', activation='sigmoid')) 
# Compile model 
model.compile(loss='binary_crossentropy', optimizer='adam', 
metrics=['accuracy']) 
# Fit the model 
model.fit(X, Y, nb_epoch=150, batch_size=10, verbose=2) 
# calculate predictions 
predictions = model.predict(X) 
# round predictions 
rounded = [round(x) for x in predictions] 
print(rounded) 
Se manja de inglês e quer um bom site como referência, sugiro o site desse tutorial 
em que me baseei para escrever esse post . 
Algumas informações sobre o Keras eu peguei no site oficial . 
A saída da execução do código de exemplo, mas utilizando TensorFlow como 
backend ( do artigo anterior ) é algo como: 
Keras usando TensorFlow | 
Rede Neural com keras 
E ao final: 
fim da execução | Rede 
Neural com keras 
Esse foi apenas um primeiro contato, em breve teremos artigos aplicáveis aos 
nossos embarcados, não deixe de acompanhar. 
 
 
 
 
 
 
 
Conclusão 
 
 
Portanto é certo também que esses processos cognitivos artificiais farão cada vez 
mais parte de nossas vidas, seja através de sistemas computacionais específicos ou 
mesmo para a pesquisa da neurociência. O uso de redes neurais em artigos 
científicos próprios das áreas biológicas também tem revelado outra tendência deste 
paradigma.