Você está na página 1de 7

Nome : Samuel Sousa  

DRE : 117040305 
Data : 19/06/2018 
 
 
 
 
 
O  perceptron  é  uma  representação  artificial  de  um  neurônio.  É  capaz  de  tomar   
entradas(valores  reais)  e  reproduzir  uma  única  saída.  Cada  uma  das  entradas  possui  um  peso de 
ligação, que indica o quanto o valor naquela entrada importa na saída. 
Exemplo: 

 
 
A entrada possui um peso associado , assim como , … possuem , ... . 
A  saída  por  sua  vez  é  computada  através  de  uma  soma  ponderada  (lembre-se  de  média 
ponderada  mas sem dividir o resultado), e através desse resultado que nosso neurônio pode ter ou 
não  uma  ativação.  Colocando  em  termos  mais  práticos,  suponha  o  seguinte  exemplo:  Está 
ocorrendo  um  festival  na  cidade,  seu  interesse  de participar é grande porém é dia de chuva forte. 
Traduzindo  esse  problema  para o perceptron podemos interpretar a entrada   como um número 
que  representa  o  quão  interessado  você  está,  e  a  entrada    como  um número indicando o quão 
ruim  é  a  chuva.  Feito  isso,  os pesos para as entradas serão escolhidos da seguinte forma : O peso 
  indica  o  ​impacto  que  sua  vontade  tem  em  ir,  e  o    o  impacto  que  chuva  faz  sobre  sua 
decisão  final.  Se  o  impacto  da  sua  vontade  é  alto,  basta  o  mínimo  interesse  em  ir  e  o  resultado 
final  é  positivo,  caso  contrário,  você teria que estar muito animado para tal. Mas como decidir se 
você  vai  ou  não  ao  festival?  Simples,  se  sua  saída  possuir  um  valor  superior  a  um  certo  limite, 
você  vai,  se  não,  você  fica  em  casa.  Tal valor limite pode ser incluído no cálculo da saída final e 
é conhecido com ​bias.   
Voltando às expressões matemáticas, a saída é expressa da seguinte forma: 

 
Se é maior que zero, você vai, se não, você fica. Este somatório é bem familiar, a soma de 
diversos produtos pode ser descrito como sendo o produto interno entre dois vetores, o vetor de 
entrada e o vetor de pesos que ligam perceptrons ao j-ésimo perceptron na camada seguinte. 
 
Até o momento, nosso perceptron funciona para um caso apenas, com pesos e ​bias​ que foram 
previamente decididos. Mas como generalizar? Ou tomar inúmeros perceptrons de forma que 
ampliem sua capacidade de produzir uma saída coerente? A resposta está no processo de 
“aprendizado” que será feito utilizando suas próprias saídas, pois as mesmas indicam se o 
resultado estava correto ou não.(Aprendizado Supervisionado) 
 
 
Para fazer uso desse processo, alteraremos os pesos e os​ bias d​ a nossa rede neural (conjunto de 
perceptrons) de forma que a cada iteração o “erro” produzido seja diminuindo até chegar ao 
mínimo possível. Considere a seguinte rede neural : 
 

 
Suponhamos  que  após  computar  uma  certa  entrada    ,  nossa  rede  neural  nos  deu  o  resultado 
357. Até então é um resultado sem sentido, mas se compararmos com o que o rede neural deveria 
responder,  suponhamos  1,  percebemos  que  há  algo  bastante  errado  aqui  e  que  precisa  ser 
corrigido.  Essa  noção  de  erro  é  que  será  utilizada  para  nos  dar  os  ajustes  necessários  em  cada 
peso  e  bias  ​das  camadas  da  rede.  Em  aplicações  reais,  357  é  um  número  bastante  alto  para  ser 
usado  como  correção  de  uma  rede,  até  porque  basta  a  mínima  alteração  para  que  o  resultado  se 
modifique  de  uma  forma  inesperada.  Por  isso,  utilizamos  o  que  chamamos  de  funções  de 
ativações.  São  funções  que  limitam  o  resultado  da  nossa  saída  em  um  intervalo  aberto  de  0  a 1. 
Dois exemplos bons são as seguintes :  
Sigmóide : 
 
 
 
Tangente Hiperbólica: 
 
 
 
 
Uma vez que o resultado já foi convertido para um valor nas funções de ativação, introduziremos 
uma nova função, a de custo. 

 
A  função  de  custo  nos  dá  uma  ferramenta  para  encontrarmos  os  valores  otimizados  dos  pesos  e 
dos  bias  q​ ue  minimizam  o  custo  final.    é  quantidade  de  dados  de  treinamento,  são  os  que 
utilizaremos  para  treinar  a  rede  a  cada  iteração.    é  o  resultado  da  rede,  pode  ser  um  único 
número,  se  a  rede  possuir  uma  única  saída, ou um vetor de números (múltiplas saídas), e   é 
o resultado que a rede deveria produzir, ou seja, a resposta “correta”. 
 
O  método  que  será  utilizado  para  encontrar  os  valores  para os pesos e os bia​s é conhecido como 
Gradiente  Descendente.  A  ideia  do  gradiente  vem  do fato de que estamos tratando de um espaço 
N-dimensional,  isto  é,  cada  peso  e  cada  bias  r​ epresenta  uma  única  variável.  Para  poder 
simplificar  a  explicação  e  tornar  um  exemplo  visível,  vamos  supor  o  seguinte  problema:  Uma 
partícula  se  encontra  numa  caixa,  onde  cada  ponto  (x,y,z)  quantifica  uma  temperatura  naquele 
ponto.  O  intuito  é  mover  a  particular  para  uma  posição  de  menor  temperatura.  A  partícula  é 
sensível  ao  calor,  dessa  forma  ela  irá  reagir  quando  perceber  que  está  esquentando.  A  cada 
instante  de  tempo  a  partícula  computa  o  gradiente  naquela  posição  e  move-se  na  direção 
contrária,  uma  vez  que  o  gradiente  indica  a  “direção”  de  maior  crescimento  da  função  (não  faz 
mais  sentido  falar  em  direção  em  um  espaço  superior  a  3  dimensões,  mas  a  ideia  é  a  mesma). 
Traduzindo essas ideias para o perceptron, obtemos as seguintes equações :  

  
 
 
  representa  a  taxa  de  aprendizado,  um  valor  que  indica  o  quão  bruscas  serão  as  variações  de 
pesos  e  bias.  S ​ urge  um  problema,  a  aplicação  dessas  fórmulas  é  feita  para  cada  entrada  de 
treinamento,  isto  significa  que  se  tivesses  dados  de  entrada  na  casa  das  dezenas  de  milhares,  o 
que  é  bastante  comum,  nosso  processo  será  bem  lento.  A  solução  para  isso  é  chamada  de 
Gradiente  Descendente  Estocástico.  A  solução  consiste  em  separar  os  dados  de  entrada  em 
“lotes”  e  aproximar  um  valor  para  o  gradiente  em  função  do  lote  todo  ao  invés  de  uma  entrada 
apenas,  isso  acelera  bastante  o  processo.  Exemplo,  temos  60000  dados  de  entrada,  escolhendo 
lotes  de  tamanho  10,  teríamos  que  computar  apenas  6000  casos,  o  que  é  uma  redução  bastante 
significativa e ainda assim apresenta bons resultados 
 
 
Juntamos  nossas  ferramentas  de  aprendizado  da  rede,  agora  falta  descobrir  por  quanto  devemos 
alterar  os  valores  de  pesos  e  ​bias  de  forma  a  alcançar  um  resultado  otimizado.  Para  isso  será 
introduzido  quatro  equações  que  regem  todos  esses  cálculos,  tal  algoritmo  é  conhecido  com 
backpropagation.​  
 
 
.  
 
 
 
 
 
 
 
 
 
O  simbolo    representa  o  erro  produzido  na  última  camada    da  nossa  rede  neural.  A primeira 
equação  indica  o  erro  na  última  camada,  ou  seja,  a  camada  de  saída.  E  relacionando  a  primeira 
equação  com  a  segunda  que  surge  a  noção de “propagar pra trás”.   é a derivada parcial da 
função  de  custo  com  respeito  ao  vetor  de saída  . Expandindo essa expressão temos :   
e    é  a  derivada  da  função  de ativação escolhida, seja ela tangente hiperbólica ou sigmóide. 
O operador realiza o produto dos elementos dos vetores (Produto de Hadamard). 
 
A  segunda  equação  relaciona  o  erro  em  uma  camada  baseado  na  camada  seguinte,  a  partir  dela 
podemos  calcular  os  erros  nas  camadas  anteriores  tendo  calculado  a  primeira  camada.    é  a 
matriz  de  pesos  transposta  aplicada ao erro na camada seguinte e novamente surge o operador de 
hadamard. 
 
A  terceira  equação  é  sem  dúvida  a  mais  simples.  Ela  retorna  a  derivada  parcial  da  função  de 
custo  em  função  do  j-ésimo  ​bias ​na camada  , e uma vez que já temos o erro calculado, já temos 
o fator de mudança de um dos bias da rede. 
 
A  quarta  e  última  equação  expressa  a  derivada  parcial  da  função  de  custo  com  respeito  ao  peso 
de  ligação  da  camada    entre o k-ésimo neurônio da camada seguinte com o j-ésimo neurônio da 
camada  atual.  Dado  pelo  produto  entre  a  saída  do  k-ésimo  neurônio  na  camada  anterior e o erro 
produzido pelo neurônio atual. 
 
 
A  ideia  por  trás  do  código  a  ser  apresentado  ao  final  é  identificar  dígitos  escritos  a  mão  por 
diversas  pessoas.  Nosso  cérebro  facilmente  pode  entender  a  diferença  entre  milhares  de  3’s  ou 
6’s escritos das diversas formas. Mas como é feita essa distinção em redes neurais? A sacada está 
em pensar em problemas menores. Suponha a rede neural a seguir: 

 
 
 
Cada  imagem  do  problema  está  compactada  em  28x28  pixels,  totalizando  784  pixels  por 
imagem.  A  entrada  da  rede  representa  o  mesmo  número. Cada entrada recebe um valor entre 0 e 
1  ,  onde  zero  é  pixel  totalmente  preto  e  1  totalmente  branco,  valores  intermediários  são  tons  de 
cinza.  A  camada  intermediária  possui  uma  funcionalidade  interessante,  a  escolha  de  15  foi  um 
número  arbitrário  e  poderia  ter  sido  qualquer  um,  basta  variar  o  valor  pra  ver  qual  escolha 
apresenta  um  resultado  mais  otimizado.  Retomando,  a  camada  intermediária  é  responsável  por 
identificar partes contidas nas imagens. Por exemplo, os números 6 e 9 possuem círculos em suas 
formações,  então  digamos  que  o  primeiro  neurônio  é  capaz  de  identificar  tais círculos, será esse 
que  irá  ser  ativado  na  hora  que  a  entrada  processar  os  respectivos  dígitos.  A  mesma  ideia  pode 
ser  aplicada  ao  1  e  4  por  exemplo,  que  possuem  “barras”. A saída é um vetor de 0 a 9 indicando 
qual dígito de entrada. O índice que possuir maior ativação é a resposta. 
 
 
 
 
 
Algoritmo da rede neural: 
 
1) Dado um conjunto de treinamento, faça: 
2) Compute a saída produzida pela rede 
3) Calcule o erro de saída 
4) A  partir  do  erro  de  saída,  “propague  para  trás”  para  descobrir  os  erros  anteriores  e  as 
respectivas derivadas parciais. 
5) A partir do resultado das derivadas, corrija os valores de peso e​ bias  
 
 
Código : ​https://colab.research.google.com/drive/1nCAMq24Oy6RIgO1yJsV-ZrymRxqcUfkZ 
Base de dados : git clone https://github.com/mnielsen/neural-networks-and-deep-learning.git 
Copie o arquivo ‘mnist.pkl.gz’ para a mesma pasta do script python. Utilize python2.  
 
 
Referências: 
 
Neural networks and deep learning, Michael Nielsen 
Using neural nets to recognize handwritten digits 
-​http://neuralnetworksanddeeplearning.com/chap1.html 
How backpropagation algorithm works 
-​http://neuralnetworksanddeeplearning.com/chap2.html 
Neural networks, 3Blue1Brown  
-​https://www.youtube.com/watch?v=aircAruvnKk&list=PLZHQObOWTQDNU6R1_67
000Dx_ZCJB-3pi 
What is bias in neural network? Quora 
-​https://www.quora.com/What-is-bias-in-artificial-neural-network