Reconhecimento de fotos para LinkedIn usando RNA

INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA
CATARINENSE - CAMPUS CAMBORIÚ
CURSO DE SISTEMAS DE INFORMAÇÃO
(BACHARELADO)
BRUNO AZEVEDO COSTA
PROTÓTIPO PARA RECONHECIMENTO DE FOTOS ADEQUADAS
PARA O PERFIL DO LINKEDIN BASEADO EM REDES NEURAIS
ARTIFICIAIS
CAMBORIÚ (SC)
2014

BRUNO AZEVEDO COSTA
PROTÓTIPO PARA RECONHECIMENTO DE FOTOS ADEQUADAS
PARA O PERFIL DO LINKEDIN BASEADO EM REDES NEURAIS
ARTIFICIAIS
Trabalho de Conclusão de Curso
submetido ao Instituto Federal
Catarinense – Campus Camboriú
para obtenção dos créditos de
disciplina com nome equivalente no
curso de Sistemas de Informação -
Bacharelado.
Orientador: Nildo Carlos da Silva, Dr.
CAMBORIÚ (SC)
2014

BRUNO AZEVEDO COSTA
PROTÓTIPO PARA RECONHECIMENTO DE FOTOS ADEQUADAS PARA O
PERFIL DO LINKEDIN BASEADO EM REDES NEURAIS ARTIFICIAIS
ESTE RELATÓRIO, DO TRABALHO DE
CONCLUSÃO DE CURSO, FOI
JULGADO ADEQUADO PARA
OBTENÇÃO DOS CRÉDITOS DA
DISCIPLINA DE TRABALHO DE
CONCLUSÃO DE CURSO, DO 8º.
SEMESTRE, OBRIGATÓRIA PARA
OBTENÇÃO DO TÍTULO DE:
BACHAREL EM SISTEMAS DE
INFORMAÇÃO
Camboriú (SC), 01 de Dezembro de 2014
Prof. Nildo Carlos da Silva, Dr.
Orientador
BANCA EXAMINADORA:
Prof. Nildo Carlos da Silva, Dr.
IFC- Câmpus Camboriú
Prof. Léo Serpa, Dr.
Prof.ª Cátia dos Reis Machado, Dra.
IFC - Câmpus Camboriú
Prof.ª Sônia Regina Lamego Lino, Dra.

LISTA DE FIGURAS
FIGURA 1 - PARTES DE UM NEURÔNIO. .......................................................................17
FIGURA 2 - MODELO DO NEURÔNIO APRESENTADO POR MCCULLOCH E PITTS..........18
FIGURA 3 - REDE MLP COM UMA ÚNICA CAMADA OCULTA........................................20
FIGURA 4 - FUNÇÃO SIGMÓIDE REPRESENTADA POR 11 + E − X................................21
FIGURA 5 - O BIAS, OU “VIÉS”, EM UMA REDE NEURAL. .............................................22
FIGURA 6 - EFEITO DO ALGORITMO DECLÍNIO DE GRADIENTE....................................26
FIGURA 7 - BACKPROPAGATION EM UMA REDE NEURAL.............................................27
FIGURA 8 - EXEMPLO DE MATRIZ TRANSPOSTA...........................................................28
FIGURA 9 - RNA UTILIZADA COMO EXEMPLO PARA CALCULAR A ETAPA DE
ALIMENTAÇÃO DIRETA DA REDE.....................................................................................29
FIGURA 10 - EXEMPLO DE MULTIPLICAÇÃO DE MATRIZES ELEMENTO POR
ELEMENTO......................................................................................................................32
FIGURA 11 - O EFEITO DO OVERFITTING. ....................................................................37
FIGURA 12 - O CONJUNTO DE DADOS É DIVIDIDO EM CONJUNTO DE
TREINAMENTO, TESTE E VALIDAÇÃO..............................................................................40
FIGURA 13 - EXEMPLO DE CURVA DE APRENDIZADO...................................................42
FIGURA 14 - SEGUNDO EXEMPLO DE CURVA DE APRENDIZADO. .................................43
FIGURA 15 - INTERFACE DE LINHA DE COMANDO DO OCTAVE....................................44
FIGURA 16 - EXEMPLO DE MULTIPLICAÇÃO DE MATRIZES..........................................49
FIGURA 17 - TELA INICIAL DO PROTÓTIPO ..................................................................51
FIGURA 18 - EXEMPLOS DE FOTOS UTILIZADAS EM PERFIS DO LINKEDIN ..................52
FIGURA 19 - À DIREITA, O EFEITO CAUSADO PELA FUNÇÃO ADJUSTIMAGE.M. ...........54
FIGURA 20 - APRESENTAÇÃO DE PARTE DOS DADOS DE ENTRADA DA REDE...............55
FIGURA 21 - ARQUITETURA INICIAL DA RNA DO PROJETO.........................................56
FIGURA 22 - COMANDO WHOS EXECUTADO APÓS INICIALIZAÇÃO DO ALGORITMO....57
FIGURA 23 - EXEMPLO DE CURVA DE APRENDIZADO GERADO NO OCTAVE.................66

LISTA DE QUADROS
QUADRO 1 - EXEMPLO DE IMPLEMENTAÇÃO DA FASE DE ALIMENTAÇÃO DIRETA
DA REDE. ........................................................................................................................29
QUADRO 2 - IMPLEMENTAÇÃO VETORIZADA DO ALGORITMO DE ALIMENTAÇÃO
DIRETA DA REDE .............................................................................................................30
QUADRO 3 - ALGORITMO BACKPROPAGTION .............................................................32
QUADRO 4 - EXPRESSÕES ARITMÉTICAS NO OCTAVE .................................................45
QUADRO 5 - OPERADORES LÓGICOS NO OCTAVE........................................................46
QUADRO 6 - DECLARAÇÃO DE VARIÁVEIS NO OCTAVE...............................................46
QUADRO 7 - EXEMPLO DE COMANDOS FOR, WHILE E IF NO OCTAVE......................47
QUADRO 8 - EXEMPLO DE FUNÇÃO QUE CALCULA O QUADRADO DE UM NÚMERO.....47
QUADRO 9 - EXEMPLO DE CHAMADA DE FUNÇÃO......................................................48
QUADRO 10 - FUNÇÃO QUE RETORNA MAIS DE UMA VARIÁVEL. ................................48
QUADRO 11 - EXEMPLO DE IMPLEMENTAÇÃO NÃO VETORIZADA...............................48
QUADRO 12 - EXEMPLO DE IMPLEMENTAÇÃO VETORIZADA.......................................49
QUADRO 13 - OBTENDO A TRANSPOSTA DE UMA MATRIZ. ..........................................49
QUADRO 14 - PARTE DA FUNÇÃO CREATEDATASET.M................................................53
QUADRO 15 - FUNÇÃO ADJUSTIMAGE.M. ...................................................................54
QUADRO 16 - INICIALIZAÇÃO DO ALGORITMO DE TREINAMENTO. .............................57
QUADRO 17 - FUNÇÃO DE INICIALIZAÇÃO DOS PARÂMETROS DA RNA .....................58
QUADRO 18 - PARTE I DA FUNÇÃO NNCOSTFUNCTION.M...........................................59
QUADRO 19 - IMPLEMENTAÇÃO DO BACKPROPAGATION...........................................59
QUADRO 20 - CÁLCULO DA FUNÇÃO DE CUSTO E GRADIENTES DOS PARÂMETROS
THETA1 E THETA2 COM REGULARIZAÇÃO. ....................................................................60
QUADRO 21 - CHAMADA DA FUNÇÃO FMINCG.M........................................................61
QUADRO 22 - EXIBINDO OS RESULTADOS DE DESEMPENHO DO TREINAMENTO..........62
QUADRO 23 - FUNÇÃO PREDICT.M..............................................................................63
QUADRO 24 - CÓDIGO DE GERAÇÃO DA CURVA DE APRENDIZADO.............................64

LISTA DE TABELAS
TABELA 1 - EXEMPLO DE UM CONJUNTO DE TREINAMENTO NÃO NORMALIZADO. .....34
TABELA 2 - TABELA COM VALORES ESCALONADOS APÓS USO DO MEAN
NORMALIZATION............................................................................................................34
TABELA 3 - DEZ MELHORES RESULTADOS OBTIDOS....................................................67

LISTA DE ABREVIATURAS E SIGLAS
GPL - General Public License
IA - Inteligência Artificial
MCP - McCulloch e Pitts
MLP - Multilayer Perceptron
RAM - Random Access Memory
RNA - Redes Neurais Artificiais

RESUMO
O presente trabalho exibe um estudo sobre os passos para criação de um sistema de
aprendizado de máquina baseado em redes neurais artificiais do tipo MLP
(Multilayer Perceptron). Os aspectos abordados são: aprendizado supervisionado,
geração e divisão do conjunto de dados, normalização de atributos, treinamento de
redes MLP por meio do algoritmo backpropagation e avaliação de resultados. Todos
esses aspectos se relacionam com o objetivo do trabalho que é, por intermédio do
backpropagation, desenvolver um sistema capaz de aprender a classificar uma foto
como adequada ou não para uso no perfil da rede social profissional LinkedIn. Isso
porque a foto utilizada neste tipo de rede social faz parte da marca profissional
online do usuário e, portanto, precisa ser escolhida de maneira cuidadosa. Dessa
forma, durante este trabalho é gerado um protótipo de software que utiliza uma rede
neural de múltiplas camadas para aprender a classificar uma determinada imagem
como apropriada ou não para o perfil do LinkedIn. Para concepção do protótipo e
implementação da RNA (Rede Neural Artificial), foram desenvolvidos algoritmos
sobre a ferramenta de distribuição livre GNU Octave versão 3.2.4, própria para
solução de problemas lineares e não lineares. Os dados (ou exemplos) utilizados no
projeto foram fotos coletadas manualmente através do download de imagens
disponíveis na internet. Ao início, foram coletadas cerca de duas mil fotos e esse
valor chegou a pouco mais de dez mil exemplos no fim do projeto. As
configurações utilizadas durante a etapa de treinamento, bem como os resultados
obtidos a partir do processo de generalização do modelo criado, são demonstradas
por meio dos experimentos e testes realizados sobre o conjunto reservado para esse
fim. Ao final, é possível observar o protótipo produzido utilizando esse método de
aprendizado de máquina obteve 88% de precisão na sua capacidade de
generalização para novos exemplos.
Palavras-chave:
Redes Neurais Artificiais, Backpropagation, Protótipo, Aprendizado de máquina.

SUMÁRIO
1 INTRODUÇÃO .........................................................................................9
1.1 Apresentação .........................................................................................9
1.2 Descrição do problema ........................................................................10
1.3 Justificativa.......................................................................................... 11
1.4 Objetivo geral ......................................................................................13
1.5 Objetivos específicos...........................................................................14
1.6 Metodologia.........................................................................................14
2 FUNDAMENTAÇÃO TEÓRICA..........................................................16
2.1 Redes Neurais Artificiais.....................................................................16
2.1.1 Componentes básicos....................................................................20
2.2 Aprendizado supervisionado em RNAs ..............................................22
2.3 Backpropagation..................................................................................24
2.3.1 Motivação .....................................................................................24
2.3.2 Notações utilizadas.......................................................................27
2.3.3 Fase FeedForward........................................................................28
2.3.4 Fase Backward..............................................................................30
2.4 Detalhes para implementação de RNAs..............................................33
2.4.1 Preparação dos dados ..................................................................33
2.4.2 Quantidade de dados para treinamento .......................................34
2.4.3 Arquitetura....................................................................................35
2.4.4 Underfitting e Overfitting .............................................................36
2.4.5 Conjuntos de treinamento, validação e teste................................39
2.4.6 Avaliação de resultados................................................................40
2.4.7 Curva de aprendizado...................................................................41
2.5 Octave..................................................................................................43
2.5.1 Operações básicas ........................................................................45
2.5.2 Funções.........................................................................................47
2.5.3 Vetorização....................................................................................48
3 DESENVOLVIMENTO..........................................................................50
3.1 Funcionamento do sistema ..................................................................50
3.1.1 Criação do conjunto de dados......................................................51
3.1.2 Arquitetura da RNA ......................................................................55
3.1.3 Treinamento da RNA.....................................................................56
3.1.4 Avaliação do treinamento .............................................................62
3.1.5 Curva de aprendizado...................................................................63
3.2 Testes e Resultados..............................................................................64
3.3 Conclusão ............................................................................................67
4 CONSIDERAÇÕES FINAIS..................................................................69
REFERÊNCIAS BIBLIOGRÁFICAS .............................................................71

9
1 INTRODUÇÃO
1.1 Apresentação
Com o avanço tecnológico e consequente surgimento da internet e das
redes e mídias sociais, muitas atividades ganharam novas maneiras, muitas vezes
mais eficientes, de serem executadas. Entre elas pode-se citar a comunicação entre
pessoas (mensagens entregues instantaneamente), o marketing e publicidade de
produtos e, para propósito desse trabalho, destacam-se a procura por emprego e o
recrutamento e seleção.
Conforme a pesquisa “Tendências globais em recrutamento para 2013”,
realizada pela empresa LinkedIn, as redes sociais profissionais se tornaram, no ano
de 2013, a principal fonte para as contratações de qualidade no Brasil. Representada
por 44%, a utilização dessas ferramentas como meio de realizar contratações de
qualidade1
dentro das empresas obteve um crescimento de 28% em apenas dois
anos (LINKEDIN, 2013).
Outra pesquisa, também realizada em 2013 e publicada pela Aberdeen
Group (2013), mostra que as redes sociais se tornaram a segunda fonte mais efetiva
no contexto geral de contratações, ficando à frente das páginas de carreiras de sites
empresariais e atrás apenas dos programas de recrutamento interno. Entre as
diferentes empresas que fornecem esses serviços, a rede social profissional
LinkedIn, contando com mais de 300 milhões de usuários ao redor do mundo, se
tornou a principal ferramenta para desempenhar os papéis de recrutamento
1
De acordo com Mahoney e Lermusi (2010), as três principais métricas para
mensurar a qualidade da contratação são: turnover (rotatividade de pessoal),
avaliação de desempenho e a satisfação do gerente de recrutamento.

10
profissional através da web (JOBVITE, 2013).
O LinkedIn, além de possibilitar aos seus usuários novas oportunidades de
trabalho, também serve como uma forma de recolocação profissional, busca por
notícias sobre a indústria e conexão com outros profissionais. Com isso, ao criar
uma conta dentro da rede, o usuário dá início a um contato rápido e direto com o
mercado de trabalho.
Diferente de outras redes sociais, como por exemplo, o Facebook2
, o perfil
no LinkedIn é extremamente profissional, havendo poucas informações sobre
hobbies, interesses religiosos ou políticos, e músicas ou filmes favoritos (SKEELS;
GRUDIN, 2009). Conforme apresentado por Skeels e Grudin (2009), o LinkedIn se
concentra na informação profissional, e por conseguinte, entende-se que a foto
exposta neste perfil também necessita ser profissional.
Visto que recrutadores ao visualizar um perfil do LinkedIn, passam mais
tempo (19% do tempo) olhando para a foto do que para outras informações vitais
dos candidatos (THE LADDERS, 2012), como por exemplo, as suas habilidades e
conhecimentos, e que a primeira impressão pode ser decisiva para uma nova e
grande oportunidade na sua carreira (CALDEIRA, 2014), a foto se torna o ponto
nevrálgico e foco deste trabalho.
A partir dessa fundamentação, este trabalho busca o desenvolvimento de
um protótipo que possibilite, por meio do aprendizado de máquina, o
reconhecimento de fotos que sejam adequadas para o perfil do LinkedIn. Para isso,
foi determinada a utilização de redes neurais artificiais que, de acordo com Russell
e Norvig (2004, p.714), é “uma das formas mais populares e efetivas de sistemas de
aprendizagem”.
1.2 Descrição do problema
O LinkedIn se tornou uma ótima ferramenta para manter profissionais
2
O Facebook é uma rede social que possibilita uma maior proximidade entre as
pessoas, tendo como uma das características o compartilhamento de vídeos, fotos
e jogos (PARENZA et al., 2013).

11
conectados ao mercado de trabalho, tanto de forma ativa quanto passiva (o usuário
não está atrás de um emprego mas pode receber propostas) (IDOETA, 2013). Ao se
criar uma conta nessa rede é preciso compreender a importância em analisar o que
está sendo exposto através dela. O usuário necessita ter a consciência de que tudo
ali remete a sua imagem profissional, podendo afetá-la de maneira positiva ou
negativa.
A problemática deste trabalho se dá no momento em que uma pessoa cria
sua conta no LinkedIn e necessita definir a foto para o seu perfil. A foto é um dos
primeiros itens que aparece ao acessar uma conta no LinkedIn e um perfil sem foto
diminui 14 vezes a sua chance de visualização (KLINE, 2014). Além disso, de
acordo com Kline (2014), a foto pode ser um fator decisivo para que um recrutador
continue a ler o restante do perfil. Logo, como definir uma foto de perfil que passe
uma boa primeira impressão e atenda aos padrões profissionais desse tipo de rede
social?
1.3 Justificativa
As redes sociais estão definitivamente transformando e facilitando os
processos de recrutamento profissional. Enquanto há algum tempo atrás a maneira
mais comum de anunciar e procurar empregos era através dos classificados de
jornais, nos Estados Unidos, 79% das vagas de trabalho já são divulgadas em sítios
de mídias sociais, sendo que 77% delas são postadas no LinkedIn (BULLHORN,
2012).
Segundo Milton Beck - diretor de soluções de talento do LinkedIn - em
conversa com a BBC Brasil, as redes sociais quebraram os paradigmas dentro do
cenário das contratações (IDOETA, 2013). Marcelo Miguel Raffaelli Filho, diretor
da consultoria Great Place to Work, considera que a utilização dessas ferramentas
possibilitou uma maior rapidez e padronização nessas atividades (IDOETA, 2013):
[...] a informação de vagas disponíveis e de candidatos interessados fica
mais rápida. [...] A padronização dos currículos também facilita a
comparação dos candidatos; e temos mais qualidade e quantidade de

12
informações disponíveis sobre eles, como cursos, conquistas profissionais
e habilidades que muitas vezes não estão no CV impresso. É uma via de
mão dupla: o candidato passa a ter (acesso) a mais conteúdo sobre as
empresas.
Apesar de muitas vezes as pesquisas tratarem as mídias sociais de forma
generalizada, o grande destaque entre elas é, de fato, o LinkedIn. Em publicação
feita na revista americana Fortune, Hempel (2010) declara que “se você está
realmente querendo gerenciar sua carreira, o único site social que interessa é o
LinkedIn”.
Embora existam muitos aspectos imprescindíveis a serem analisados
durante a criação de um perfil dentro do LinkedIn, uma das partes mais importantes
é a foto (DOYLE, 2014). A opção de adicionar foto ao perfil surgiu para facilitar as
pessoas na formação de conexões profissionais online mais ricas (NASH, 2007).
Entretanto, desde sua criação, já foi salientada a esperança da empresa sobre a
qualidade das fotos utilizadas.
Conscientes de que os usuários se importem com sua reputação
profissional, a expectativa por parte do LinkedIn, desde o momento em que a
funcionalidade de adicionar foto ao perfil foi desenvolvida, já era de que essas fotos
fossem profissionais por natureza (NASH, 2007). Porém, é visto que muitas pessoas
ainda não se atentam a esse aspecto crucial.
O headhunter André Caldeira (2014) constata a displicência de muitos
usuários quanto a essa questão: “[...] Quase todos os dias me deparo com imagens
que parecem vir diretamente da turma de colegas do 3º ano fundamental da minha
filha de 8 anos”. Além disso, Caldeira adverte que a primeira impressão pode ser
decisiva para o usuário ser considerado para uma nova e grande oportunidade de
trabalho.
Para compreender os aspectos que contribuem para uma boa foto de perfil
no LinkedIn, pode-se considerar algumas das recomendações dada por Alison
Doyle3
(DOYLE, 2013):
 Selecione uma foto de rosto: a foto deve conter apenas a cabeça,
3
Alison Doyle é uma expert em recursos humanos e buscas de emprego. Desde
1998 dirige o site de busca por empregos da About.com.

13
pescoço e um pouco dos ombros;
 Vista-se profissionalmente: tenha certeza que sua foto apresente você
de forma apropriada para sua área. Vestir-se profissionalmente
também significa se vestir de maneira limpa e simples.
 Mantenha a simplicidade: não inclua objetos, animais de estimação,
crianças ou outras pessoas. Evite fundos visualmente poluídos –
posicionar-se na frente de um fundo de cor sólida e leve é a melhor
escolha;
Levando em consideração o que foi descrito nos últimos parágrafos,
conclui-se a viabilidade de desenvolver um sistema inteligente que possa identificar
se determinadas imagens são irregulares de acordo com o propósito da rede. Um
dos meios possíveis para se conseguir isso é através da utilização de redes neurais
artificiais (RNAs). Essas redes proporcionam soluções apropriadas para problemas
de classificação caracterizados por relações não lineares, dados complexos,
imperfeitos ou propícios a erros sensoriais e que não possuem soluções matemáticas
ou algoritmos claros (SEETHA et al., 2008).
Para Seetha et al. (2008), o grande diferencial das RNAs está na sua
capacidade de melhorar a precisão do treinamento, e o seu benefício principal é a
possibilidade de construir o modelo do sistema a partir dos dados disponibilizados.
Além disso, as RNAs têm sido utilizadas em várias aplicações dentro desse contexto
(THAY et al., 2012) e, de acordo com Luger (2009, p.680), sendo corretamente
treinadas, podem efetivamente categorizar novos exemplos apresentando a
percepção humana de similaridade.
1.4 Objetivo geral
O objetivo deste trabalho é produzir um protótipo que seja capaz de,
através do uso de redes neurais artificiais, aprender a classificar imagens a partir de
dados já conhecidos e classes pré-estabelecidas, a fim de solucionar o problema
levantado neste trabalho.

14
1.5 Objetivos específicos
Para este trabalho, têm-se como objetivos específicos:
a) Identificar as características e atributos de fotos consideradas
adequadas e inadequadas para utilização em redes sociais profissionais;
b) Realizar a coleta dos exemplos para composição do conjunto de
dados a ser utilizado na aplicação;
c) Criar funções na linguagem Octave para pré-processamento dos
dados, implementação da RNA e testes de precisão.
d) Demonstrar a qualidade do conhecimento adquirido pelas RNAs
para solução do problema deste trabalho.
1.6 Metodologia
O presente trabalho parte de uma pesquisa experimental, que segundo
Best (1972, apud LAKATOS; MARCONI, 2008), acontece quando existe controle
sobre determinados fatores e sua importância está nas relações de causa e efeito.
Outra definição para esse tipo de pesquisa é dada por Hymann (1967, apud
LAKATOS; MARCONI, 2008): “Levantamentos explicativos, avaliativos e
interpretativos, que têm como objetivos a aplicação, a modificação e/ou a mudança
de alguma situação ou fenômeno”.
Em relação aos objetivos, a pesquisa utilizada foi a exploratória, mais
precisamente, estudos de manipulação experimental. A determinação desse tipo de
pesquisa pode ser compreendida a partir da conceituação dada por Lakatos e
Marconi (2008):
[...] consistem naqueles estudos exploratórios que têm por finalidade
manipular uma variável independente, a fim de localizar variáveis
dependentes que potencialmente estejam associadas a ela, estudando-se o
fenômeno em seu meio natural. O propósito desses estudos geralmente é
demonstrar a viabilidade de determinada técnica ou programa como uma
solução, potencial e viável, para determinados programas práticos. Os

15
procedimentos de coleta de dados variam bastante e técnicas de
observação podem ser desenvolvidas durante a realização da pesquisa.
As etapas iniciais deste trabalho foram estabelecidas de acordo com os
procedimentos usualmente adotados na maioria dos processos de aprendizado de
máquina. Portanto, na parte preliminar do projeto foi realizada a identificação das
características decorrentes de uma foto declarada como sendo de qualidade
profissional e ideal para o perfil do LinkedIn. A partir dos atributos identificados
nesse levantamento, iniciou-se a fase de criação do conjunto de dados, que constitui
parte fundamental para qualquer algoritmo de aprendizado de máquina.
A criação do conjunto de dados que foram utilizados como entradas para o
algoritmo desenvolvido foi feita através da seleção manual e download de imagens
disponíveis na internet. Para melhor precisão do treinamento das RNAs, foram
coletadas quantidades significativas de imagens que representavam fotos
inadequadas e adequadas para uso no perfil da rede social. A necessidade de
aumentar o tamanho do conjunto de dados surgiu a partir de análises feitas durante
o projeto.
Após a coleta dos dados, a próxima etapa constituiu-se no carregamento e
tratamento desses dados dentro do Octave, onde foi realizado o redimensionamento
das imagens para dimensões padrões, conversão para escala de cinza, e por fim,
foram normalizados os valores dos pixels para valores próximos a zero. Além disso,
o conjunto de dados foi separado em dois grupos: training set (conjunto de
treinamento) e test set (conjunto reservado para execução de testes).
As etapas finais se destinaram ao desenho da arquitetura da rede neural a
ser utilizada, realização do treinamento da rede com o algoritmo backpropagation e
avaliação dos resultados por meio da generalização no conjunto de teste. Durante
todo o projeto foram realizados ajustes e revalidação do modelo desenvolvido a fim
de se obter melhor desempenho e precisão.

16
2 FUNDAMENTAÇÃO TEÓRICA
Como visto anteriormente, o problema do presente trabalho consiste na
tarefa de classificar imagens como ideais ou não para o perfil do LinkedIn. O
problema de classificação de imagem é um dos clássicos problemas relacionados a
processamento de imagem, tendo como objetivo predizer as categorias de novas
imagens utilizando seus próprios atributos (THAY et al., 2012).
Dentre as variadas abordagens existentes para resolver problemas de
classificação de imagem, a escolhida para este projeto foi a técnica de redes neurais
artificiais. Ao se trabalhar com classificação de imagens, a quantidade de atributos
que compõe o conjunto de entrada, representado por pixels, pode ser muito grande,
constituindo assim problemas extremamente complexos. Com isso, as redes neurais
artificiais são uma alternativa para que algoritmos dentro desse ambiente tenham
um bom desempenho, já que elas são capazes de trabalhar com modelos não
lineares (NG, 2014).
Este capítulo destina-se à fundamentação teórica do presente trabalho,
com o objetivo de apresentar definições, conceitos e conhecimentos necessários
para entendimento do funcionamento do protótipo desenvolvido.
2.1 Redes Neurais Artificiais
A neurociência, apresentada por Russell e Norvig (2004, p.12), é o estudo
do sistema nervoso, particularmente o cérebro, e, de acordo com os autores, foi uma
das disciplinas que teve importantíssima contribuição para o campo da IA
(Inteligência Artificial) e consequentemente para o surgimento das RNAs.

17
Em 1861, um estudo da afasia feito por Paul Broca com pacientes cujos
cérebros foram danificados permitiu o conhecimento da existência de áreas
localizadas do cérebro responsáveis por funções cognitivas específicas; mas
somente em 1873 foi possível observar os neurônios do cérebro individualmente
(RUSSELL; NORVIG, 2004, p.12). Por fim, a conclusão alcançada por Searle
(1992 apud RUSSELL e NORVIG, 2004, p.13), foi de que uma “coleção de células
simples pode levar ao pensamento, à ação e à consciência”.
Figura 1 Partes de um neurônio.
Fonte: Russell e Norvig (2004, p.13)
Atualmente sabe-se, conforme explicitado por Marsland (2009, p.11), que
o cérebro é um sistema poderoso e complexo capaz de lidar com dados distorcidos e
muitas vezes inconsistentes, e produz respostas rápidas e geralmente corretas sobre
esses dados. Este órgão é composto por células nervosas, unidades processadoras do
cérebro, chamadas neurônios (Figura 1), e cada um deles pode ser visto como um
processador separado (MARSLAND, 2009, p.11-12). As RNAs, por sua vez,
baseiam-se nesse modelo para tentar “reproduzir com fidelidade várias funções
cognitivas e motoras dos seres humanos” (BRAGA et al., 2014, p.6).
De acordo com Russell e Norvig (2004, p.18), o primeiro trabalho
desenvolvido reconhecido como IA foi realizado por Warren McCulloch e Walter
Pitts, em 1943, onde ambos propuseram um modelo de neurônios artificiais
caracterizados por status “ligado” ou “desligado”, ocorrendo a troca de status para

18
“ligado” em resposta à estimulação por um número suficiente de neurônios
vizinhos.
Figura 2 Modelo do neurônio apresentado por McCulloch e Pitts.
Fonte: Marsland (2009, p.14)
Nesse modelo, apresentado na Figura 2, McCulloch e Pitts provaram que
qualquer função computável podia ser calculada por certa rede de neurônios
conectados, e que todos conectivos lógicos podiam ser implementados por
estruturas de redes simples. Por fim, eles sugeriram que se definidas
adequadamente, essas redes seriam capazes de aprender.
Considerando outros trabalhos importantes para história e evolução das
RNAs, tem-se o trabalho desenvolvido por Rosenblatt, o perceptron (BRAGA et al.,
2014, p. 4). A partir desse novo modelo, Rosenblatt demonstrou que “se fossem
acrescidas sinapses ajustáveis as RNAs com neurônios MCP poderiam ser treinadas
para classificar certos tipos de padrões” (BRAGA et al., 2014, p. 4). Seu objetivo,
conforme descrito por Braga et al. (2014, p.4), era desenvolver RNAs que fossem
capazes de fazer descobertas interessantes sem a necessidade de seres humanos
estabelecendo regras explícitas para isso.
Segundo Braga et al. (2014, p.4-5), os estudos sobre RNAs desapareceram
durante os anos de 1970, e ressurgiram na década de 1980, com a descrição do
algoritmo backpropagation (algoritmo utilizado neste trabalho e detalhado no item
2.3). A partir desse momento, foi possível provar que RNAs com múltiplas camadas
eram capazes de resolver problemas complexos, anteriormente impossíveis de se
resolver através dos modelos com uma única camada, e desde então, pesquisas e
estudos voltados para RNAs ganharam bastante atenção permanecendo forte até os

19
dias atuais (BRAGA et al., 2014, p.5).
As RNAs, consoante com Braga et al. (2014, p.18), são normalmente
aplicadas a situações em que “existem dados, experimentais ou gerados por meio de
modelos, por meio dos quais a rede adaptará os seus pesos visando à execução de
uma determinada tarefa”. Braga et al. (2014, p.18) ainda descrevem que as
principais tarefas em que as RNAs se aplicam são: classificação, categorização
(clustering), aproximação, previsão e otimização. Devido sua importância para
desenvolvimento do corrente trabalho, observa-se a seguir, de forma minuciosa, no
que consistem as tarefas de classificação:
Problemas de classificação envolvem a tarefa de atribuir a um padrão
desconhecido uma entre várias classes conhecidas. A resolução de
problemas de classificação por meio de RNAs se caracteriza basicamente
por aprendizado supervisionado, em que exemplos, de padrões são
apresentados às entradas e as classes correspondentes são apresentadas às
saídas da rede durante o processo de aprendizado. A rede deverá, então,
adaptar os seus pesos de forma a mapear as relações entre padrões de
entrada e classes correspondentes de saída, tendo por base os dados do
conjunto de treinamento. Assim, a classificação envolve, após o
treinamento, atribuir uma das classes conhecidas a um padrão qualquer de
entrada (BRAGA et al., 2014, p.18).
Em conformidade com o que foi exposto por Braga et al. (2014, p.18),
constata-se que a aprendizagem é uma etapa essencial para que seja possível
realizar as tarefas de classificação. De forma geral, essa etapa se resume em
apresentar um conjunto de exemplos para a rede, possibilitando a ela extrair as
características necessárias para representar a informação recebida e para
posteriormente “gerar respostas para o problema” (BRAGA et al., 2014, p.3). Essa
capacidade das RNAs em aprender com dados existentes e fornecer respostas
coerentes a dados ainda não conhecidos (generalização), extraindo informações
implícitas, é sem dúvida, segundo Braga et al. (2014, p.3), o seu principal atrativo.

20
Figura 3 Rede MLP com uma única camada oculta.
Fonte: Adaptado de Marsland (2009, p.48)
A importância das RNAs no contexto de reconhecimento de padrões
também é ressaltada por Bishop (2006, p.226) que considera a arquitetura
Perceptron de Múltiplas Camadas (MLP), visto na Figura 3, como solução para
problemas de larga escala, o modelo de maior sucesso.
Dado o exposto, pode-se observar que as RNAs representaram os
trabalhos iniciais de IA e tiveram um grande papel no nascimento e evolução desse
campo. Além disso, conclui-se que as RNAs são ótimas ferramentas para solução de
problemas complexos e não lineares.
2.1.1 Componentes básicos
É possível destacar como componentes básicos da estrutura e processo de
aprendizagem em redes neurais, unindo a notação utilizada por Marsland (2009,
p.18-19) em seu livro Machine Learning – An Algorithmic Perspective com a
abordagem de Russell e Norvig (2004, p.714-718), os seguintes itens:
Unidades: As unidades, ou nós, compõem a estrutura da rede neural e são
conectadas por vínculos orientados. Uma unidade i é vinculada a uma unidade j
propagando a ativação de 𝑎𝑖, desde i até j;
Camadas (layers): As camadas fazem parte da organização de uma rede
neural e podem ser entendidas como um conjunto de unidades, ou nós. Em uma

21
rede de alimentação direta, cada unidade de uma camada só pode receber a entrada
de unidades que fazem parte de camadas precedentes. Em relação ao número de
camadas contidas em uma rede neural, isso poderá variar de acordo com o tipo de
rede. As redes MCP têm apenas duas camadas, sendo elas a camada de entrada e a
camada de saída. As redes MLP, além de possuírem camadas de entrada e de saída,
também possuem as chamadas camadas ocultas, ou intermediárias.
Entradas (inputs): Um vetor de entrada é o dado que serve como entrada
para a rede neural. Normalmente escrito como x, com elementos 𝑥𝑖, onde i inicia-se
em um e segue até o número correspondente às dimensões da entrada;
Pesos (ou parâmetros): São representados por uma matriz W contendo
elementos 𝑤𝑖𝑗, que determinam os pesos associados às conexões entre os nós i e j.
Esses pesos são equivalentes às sinapses do cérebro e a dimensão da matriz W será
estabelecida de acordo com o tamanho de unidades entre as camadas conectadas
correspondentes;
Função de Ativação: Uma função de ativação 𝑔 é uma função matemática
que determina a saída de um neurônio de acordo com o resultado da soma
ponderada de suas entradas. Essa função possibilita que, como descrito por Russell
e Norvig (2004, p.714), “a unidade seja ‘ativa’ (próxima de +1) quando as entradas
‘corretas’ forem recebidas e ‘inativa’ (próxima a 0) quando as entradas ‘erradas’
forem recebidas”. A fórmula de ativação de um neurônio 𝑎𝑗 é definida por 𝑎𝑗 =
𝑔(∑ 𝑊𝑖𝑗 𝑎𝑖
𝑛
𝑖=1 ) e uma eventual escolha para 𝑔 é vista na Figura 4.
Figura 4 Função sigmóide representada por
𝟏
𝟏+𝒆−𝒙.
Saídas (outputs): As saídas de uma rede neural são os valores encontrados

22
nas unidades da última camada desta rede. O tamanho do vetor de saída
corresponderá à quantidade de unidades na camada de saída da rede, sendo
representado por 𝑦𝑖 e calculado por uma hipótese h.
Alvo (target): O alvo em uma rede neural é um dado extra, necessário
para a aprendizagem supervisionada. Neste tipo de aprendizagem, durante o
treinamento da rede, não basta fornecer apenas as entradas 𝑥𝑖, é preciso também
fornecer a “resposta correta” que deverá ser aprendida. Por esse motivo deve existir
um vetor alvo 𝑡𝑗, onde j inicia-se em um e percorre o número correspondente à
quantidade de unidades na camada de saída.
Erro: O erro é uma função que calcula a imprecisão da rede de acordo
com os alvos fornecidos 𝑡𝑖 e as saídas calculadas 𝑦𝑖.
Bias: O bias, ou “viés”, é uma unidade extra de entrada para cada
neurônio configurada com um valor fixo igual a um. De acordo com Conceição
(2009, p.24) ele “representa um peso sináptico atribuído ao próprio neurônio”. Na
Figura 5 é possível verificar como o viés é aplicado em uma rede MCP.
Figura 5 O bias, ou “viés”, em uma rede neural.
Fonte: Adaptado de Ng (2014)
2.2 Aprendizado supervisionado em RNAs
Como visto na descrição sobre a aplicabilidade das RNAs a problemas de
classificação, no item 2.1, pode-se concluir que a resolução do problema inerente a
este trabalho está inserida no contexto de aprendizado supervisionado. Porém, antes
de compreender o que significa “aprendizado supervisionado”, é imprescindível

23
considerar a definição geral do que vem a ser aprendizado.
Simon (1983, apud LUGER, 2009, p.388) descreve, de maneira sucinta,
que aprendizado pode ser compreendido como “qualquer mudança em um sistema
que o permita ter um desempenho melhor na segunda vez em que se repete a mesma
tarefa”. Mesmo que breve essa descrição resume muito do que acontece no
desenvolvimento de programas com capacidade de aprender (LUGER, 2009,
p.388).
Uma definição um pouco mais técnica, partindo para o conceito de
aprendizado de máquina, é dada por Mitchell (1997, p.2) e determina que “Um
computador aprende a partir de uma experiência E de acordo com alguma tarefa T e
algum desempenho mensurado P, se seu desempenho em T, medido por P, melhora
através da experiência E”. Contudo, é possível observar que, apesar de apresentado
de forma diferente, o conceito explorado por Mitchell sobre aprendizado é similar
ao abordado por Simon.
Outra visão sobre aprendizado, desta vez inserida no cenário das RNAs, é
apresentada a seguir:
Aprendizado é o processo pelo qual os parâmetros livres de uma rede
neural são ajustados por meio de uma forma continuada de estímulo pelo
ambiente externo, sendo o tipo específico de aprendizado definido pela
maneira particular como ocorrem os ajustes dos parâmetros livres
(MENDEL; MCLAREN, 1970, apud BRAGA et al., 2014, p.12).
Logo, conforme a citação de Mendel e McLaren, o tipo de aprendizado
está ligado à maneira como as mudanças são feitas no sistema, ou mais
tecnicamente falando, à maneira como os parâmetros desses sistemas são ajustados
para melhorar a precisão em sua generalização (BRAGA et al., 2014, p.12).
Uma das maneiras de se compreender o que foi descrito por Mendel e
McLaren é analisar a seguinte fórmula apresentada por Braga et al. (2014, p.12):
“𝑤( 𝑡 + 1) = 𝑤( 𝑡) + ∆𝑤(𝑡)”. Com essa fórmula, o autor descreve o processo de
aprendizagem, onde “𝑤( 𝑡) e 𝑤( 𝑡 + 1) representam os valores dos pesos nos
instantes 𝑡 e 𝑡 + 1, respectivamente, e ∆𝑤(𝑡) é o ajuste aplicado aos pesos”. Com
isso, o paradigma no qual se enquadra determinado algoritmo de aprendizado é

24
estabelecido pela forma como ∆𝑤( 𝑡) é calculado (BRAGA et al., 2014, p.12).
Entre os principais paradigmas de aprendizado mencionados por Braga et
al. (2014, p.13) está o aprendizado supervisionado. Para detalhar esse tipo de
aprendizado, Russell e Norvig (2004, p.630) descrevem que “o problema da
aprendizagem supervisionada envolve a aprendizagem de uma função a partir de
exemplos de suas entradas e saídas”.
Corroborando as ideias de Russell e Norvig sobre aprendizado
supervisionado, Braga et al. (2014, p.13) consideram a necessidade da figura de um
supervisor, que será responsável por observar a saída calculada pelo algoritmo e
comparar o resultado com o valor de saída desejado. Levando em consideração a
fórmula apresentada anteriormente, pelo mesmo autor, o aprendizado
supervisionado pode ser caracterizado como os ajustes do conjunto de pesos 𝑤𝑖 de
maneira a aproximar a saída calculada com a saída desejada. Logo, a cada etapa de
treinamento desse tipo de sistema, é esperado minimizar essa diferença a fim de se
chegar a uma possível solução (BRAGA et al., 2014, p.13).
Para realizar os cálculos anteriormente abordados, o aprendizado
supervisionado é composto por diversos tipos de algoritmos, que visam obter um
mapeamento dos padrões de entrada e saída. Entre eles, um dos mais conhecidos,
aplicado a redes de múltiplas camadas, é o algoritmo backpropagation, que será
tratado a seguir (BRAGA et al., 2014, p.13).
2.3 Backpropagation
2.3.1 Motivação
Em redes de uma única camada, o treinamento e o aprendizado da rede
são realizados através da correção de erros, que busca “minimizar o erro da resposta
atual da rede em relação à saída desejada” (BRAGA et al., 2014, p.13). De acordo
com Ng (2014), a fórmula ideal para calcular esse erro, em tarefas de classificação,
é representada pela seguinte função 𝐸:

25
𝐸(ℎ 𝑊( 𝑥), 𝑡) = −𝑡 log ℎ 𝑊( 𝑥) − (1 − 𝑡) log(1 − ℎ 𝑊( 𝑥)) (1)
, onde ℎ 𝑤( 𝑥) representa a hipótese (saída do neurônio) para um dado exemplo x e 𝑡
simboliza o valor da saída verdadeira (a “resposta correta”) deste exemplo.
A hipótese ℎ 𝑊( 𝑥), nesse contexto, é probabilidade de y (a saída) ser igual
a 1, dado x, parametrizado pelos pesos W (NG, 2014). A mesma é calculada
aplicando uma função de ativação à soma ponderada da entrada 𝑥, como pode ser
visto a seguir (RUSSELL; NORVIG, 2004, p.717-718):
ℎ 𝑊( 𝑥) = 𝑔 (∑ 𝑊𝑗 𝑥𝑗
𝑛
𝑗=1
) (2)
Uma função de custo 𝐽 utiliza os erros de todos os m exemplos do
conjunto de treinamento para calcular o custo associado ao aprendizado. De certo
modo, pode-se dizer que essa função (Equação 3) determina quão bem a rede neural
está adaptada para predizer o exemplo i.
𝐽( 𝑊) = −
1
𝑚
[∑ 𝑡𝑖 log ℎ 𝑊( 𝑥𝑖) + (1 − 𝑡𝑖) log(1 − ℎ 𝑊( 𝑥𝑖))
𝑚
𝑖=1
] (3)
Uma das maneiras existentes para minimizar o erro associado à RNA é
utilizar o algoritmo de declínio de gradiente, que calcula a derivada parcial da
função 𝐽 em relação a cada peso (RUSSELL; NORVIG, 2004, p.718). Dessa forma,
os pesos da rede são atualizados da seguinte maneira:
𝑊𝑗 = 𝑊𝑗 − 𝛼
𝜕
𝜕𝑊𝑗
𝐽( 𝑊) (4)
, em que 𝛼 simboliza a taxa de aprendizagem4.
O algoritmo completo do declínio de gradiente consiste em repetir a
atualização dos pesos 𝑊𝑗, todos simultaneamente, até sua convergência,
minimizando a função 𝐽 (NG, 2014).
4
A taxa de aprendizagem, uma constante α, reflete no quanto os valores dos
pesos são modificados, sendo que, quanto maior o seu valor, mais rápido os
pesos se aproximam de um valor ótimo (LUGER, 2009, p.467).

26
Figura 6 Efeito do algoritmo declínio de gradiente.
O efeito do algoritmo de declínio de gradiente em uma função não
convexa é ilustrado na Figura 6. Na figura, Marsland (2009, p.51) propõe a ideia de
uma bola rolando sobre uma superfície e, conforme a força da gravidade, descendo
até atingir uma das cavidades dessa superfície. Neste momento, é dito que o
algoritmo encontrou um local mínimo.
É importante salientar que para funções convexas não existem locais
mínimos. Nesse caso, existe apenas um mínimo global, e por esse motivo, ao
executar o algoritmo de declínio de gradiente não há riscos de o algoritmo ficar
parado em um local mínimo e não encontrar o ponto ótimo global (NG, 2014).
A utilização da função 𝐽 em conjunto com o algoritmo de declínio de
gradiente, indicado previamente, é satisfatória para o aprendizado em redes de uma
única camada. Todavia, para redes de múltiplas camadas, apenas essas duas
abordagens não são o suficiente, conforme pode ser observado a seguir:
[...] Para redes de uma única camada, o erro é obtido diretamente através
da diferença entre a saída desejada e a saída corrente da rede. No entanto
para múltiplas camadas esse procedimento pode ser aplicado somente
para a camada de saída, já que não existem saídas desejadas definidas
para as camadas intermediárias. Assim, o problema passa a ser então,
como calcular ou estimar o erro das camadas intermediárias (BRAGA et
al., 2014, p.67).
De acordo com Braga et al. (2014, p.67), é possível identificar a existência
de um problema relacionado às redes de múltiplas camadas. Braga et al. (2014,
p.67) destacam que o erro nas camadas ocultas (intermediárias), necessita ser
estimado, entretanto, não pode ser calculado da mesma maneira como se é feito nas

27
redes de uma única camada. Dessa forma, para contornar esse impasse, no ano de
1986, foi descrito o algoritmo backpropagation, que em sua fase backward (fase de
retorno) possibilita computar os erros associados a essas camadas.
Figura 7 Backpropagation em uma rede neural.
Fonte: Luger (2008, p.468)
O algoritmo backpropagation, conforme representado na Figura 7, possui
duas etapas. A primeira etapa é a compreendida como a alimentação direta da rede
(Forward Network Activation) e a segunda, é conhecida como propagação de
retorno (Backwards Error Propagation), ou retropropagação, que é responsável por
estimar os erros associados às camadas ocultas (RUSSELL; NORVIG, 2004, p.721).
Essas duas fases serão analisadas na sequência, e por fim, será
apresentado o algoritmo final que corresponde à aprendizagem supervisionada por
meio de redes neurais artificiais de múltiplas camadas.
2.3.2 Notações utilizadas
Para a descrição do algoritmo backpropagation serão adotadas as
seguintes notações:
- L: o número total de camadas que compõem a rede;
- 𝑠𝑙: número de unidades (desconsiderando a unidade bias) na camada l.
- 𝑎𝑗
(𝑙)
: ativação da unidade j na camada l;
- 𝑊(𝑙)
: matriz de parâmetros, ou pesos, que controla a função de
mapeamento da camada l até a camada l +1, com dimensões 𝑠𝑗+1 ×

28
(𝑠𝑗 + 1).
- (𝑊(𝑙)
)
𝑇
: matriz transposta de 𝑊(𝑙)
.
Figura 8 Exemplo de matriz transposta.
Fonte: Elaborado pelo autor
2.3.3 Fase FeedForward
O algoritmo backpropagation é iniciado pela fase de alimentação direta da
rede (feedforward). Nesta parte do algoritmo, o processo é similar ao descrito no
início deste capítulo, em que os sinais são recebidos nas camadas de entrada e são
propagados até a camada de saída. Contudo, a única diferença é que, nas redes de
múltiplas camadas, essa propagação exigirá mais cálculos e mais do que um único
conjunto de pesos para encontrar o valor final correspondente à saída da rede.
Para reforçar o entendimento dessa etapa, considerando uma arquitetura
MLP com uma única camada oculta, Marsland (2009, p.54) descreve o seguinte
processo: um vetor de entrada é colocado nas unidades de entrada da rede neural; as
unidades de entrada e a primeira camada de pesos são usadas para definir a ativação
dos neurônios da camada oculta, aplicando a função sigmoide; as saídas dos
neurônios da camada oculta são usadas juntamente com a segunda camada de pesos
para determinar a ativação dos neurônios da camada de saída da rede.
No intuito de deixar mais claro o que ocorre na etapa de alimentação
direta da rede, o Quadro 1 apresenta um exemplo do algoritmo, considerando uma
RNA com arquitetura correspondente à Figura 9 e um único exemplo x.

29
Figura 9 RNA utilizada como exemplo para calcular a etapa de
alimentação direta da rede.
Quadro 1 Exemplo de implementação da fase de alimentação direta da rede.
Fonte: elaborado pelo autor
É importante observar que a parte de inicialização do algoritmo consiste
na configuração dos valores dos parâmetros a serem utilizados. A inicialização
𝑧1
(2)
= 𝑊10
(1)
𝑥0⏟
𝑏𝑖𝑎𝑠
+ 𝑊11
(1)
𝑥1 + 𝑊12
(1)
𝑥2 + 𝑊13
(1)
𝑥3
𝑎1
(2)
= 𝑔(𝑧1
(2)
)
𝑧2
(2)
= 𝑊20
(1)
𝑥0 + 𝑊21
(1)
𝑥1 + 𝑊22
(1)
𝑥2 + 𝑊23
(1)
𝑥3
𝑎2
(2)
= 𝑔(𝑧2
(2)
)
𝑧3
(2)
= 𝑊30
(1)
𝑥0 + 𝑊31
(1)
𝑥1 + 𝑊32
(1)
𝑥2 + 𝑊33
(1)
𝑥3
𝑎3
(2)
= 𝑔(𝑧3
(2)
)
𝑧(3)
= 𝑊10
(2)
𝑎0
(2)
⏟
𝑏𝑖𝑎𝑠
+ 𝑊11
(2)
𝑎1
(2)
+ 𝑊12
(2)
𝑎2
(2)
+ 𝑊13
(2)
𝑎3
(2)
ℎ 𝑊(𝑥) = 𝑎(3)
= 𝑔(𝑧(3)
)
 Inicialização
- Inicialize todos os pesos com valores baixos (positivos e
negativos).
 Treinamento
Fase forward
∙ Calcule a ativação de todos os neurônios 𝑎𝑗
(𝑙)
:
Fase backward
...

30
desses parâmetros deve acontecer de forma aleatória, objetivando solucionar o
problema de pesos simétricos (problem of symmetric weights). Além disso, de
acordo com Ng (2014), esses valores devem ser baixos, positivos e negativos,
compreendendo uma faixa entre –𝜀 e 𝜀 (−𝜀 ≤ 𝑊𝑖𝑗
(𝑙)
≤ 𝜀) (NG, 2014).
O Quadro 2 apresenta outro código para implementação da etapa de
alimentação da rede, que corresponde à versão vetorizada5
do código descrito no
Quadro 1.
Quadro 2 Implementação vetorizada do algoritmo de alimentação direta da rede
2.3.4 Fase Backward
Na fase backward do algoritmo backpropagation, o objetivo é calcular os
erros associados a cada uma das camadas da rede neural. Ou seja, além de calcular o
erro na camada de saída, é necessário também calcular os erros associados às
camadas ocultas. Segundo Russell e Norvig (2004, p.721), “o erro nas camadas
ocultas parece misterioso, porque os dados de treinamento não informam que valor
os nós ocultos devem ter”.
5
Ng (2014) destaca que a vetorização possibilita códigos mais eficientes e
capazes de serem executados com mais rapidez. No item 3.1 esse conceito é
abordado mais detalhadamente.
𝑎(1)
= 𝑥
𝑧(2)
= 𝑊(1)
𝑎(1)
𝑎(2)
= 𝑔(𝑧(2)
)
𝑧(3)
= 𝑊(2)
𝑎(2)
ℎ 𝑊(𝑥) = 𝑎(3)
= 𝑔(𝑧(3)
)
Fase forward
∙ Calcule a ativação dos neurônios 𝑎(2)
e 𝑎(3)
:
Fase backward
...

31
Nessa etapa do algoritmo, o objetivo é descobrir o erro pertencente às
camadas ocultas da rede. Para isso, é necessário “efetuar a propagação de retorno da
camada de saída para as camadas ocultas” (RUSSEL; NORVIG, 2004, p.721).
Segundo Russell e Norvig (2004, p.721), esse processo “emerge diretamente de
uma derivação do gradiente de erro global”.
Consoante com Ng (2014), a intuição do algoritmo backpropagation é que
para cada unidade da rede, deverá ser calculado o termo 𝛿𝑗
(𝑙)
, que representa o erro
do nó j na camada l, para 𝑙 ≥ 2. Com isso, ainda considerando o exemplo da Figura
8, a unidade na camada de saída tem seu erro calculado por 𝛿(3)
= 𝑎(3)
− 𝑡, onde
𝑎(3)
corresponde ao valor da hipótese de saída do neurônio da camada de saída
(camada 3) e t representa a saída desejada.
Como descrito por Russell e Norvig (2004, p.721), o erro encontrado na
camada de saída é propagado para as camadas anteriores, a fim de possibilitar
calcular o erro nas unidades dessas camadas. Portanto, o cálculo do termo 𝛿𝑗
(𝑙)
é
dado pela seguinte equação (NG, 2014):
𝛿𝑗
(𝑙)
= 𝑔′
(𝑧𝑗
(𝑙)
) ∑ 𝑊𝑖𝑗
(𝑙)
𝑛
𝑖=1
𝛿𝑖
(𝑙+1)
(5)
, onde o termo 𝑔′ significa a derivada da função de ativação 𝑔 avaliada nas entradas
dadas por 𝑧𝑗
(𝑙)
. O cálculo dessa derivada resulta em 𝑎𝑗
(𝑙)
(1 − 𝑎𝑗
(𝑙)
) (NG, 2014).
Em redes neurais MLP, a derivação da função 𝐽 (Equação 3) é
compreendida como sendo a multiplicação das ativações 𝑎𝑗
(𝑙)
pelos erros
encontrados 𝛿𝑖
(𝑙+1)
. Dessa forma, tem-se que:
𝜕
𝜕𝑊𝑖𝑗
(𝑙)
𝐽( 𝑊) = 𝑎𝑗
(𝑙)
𝛿𝑖
(𝑙+1)
(6)
Como foi visto anteriormente, na etapa de alimentação da rede, também é
possível escrever o cálculo do termo 𝛿 para qualquer unidade de uma camada
intermediária l, de forma vetorizada. Portanto, sua versão vetorizada é dada pela
equação 𝛿(𝑙)
= (𝑊(𝑙)
)
𝑇
𝛿(𝑙+1)
.∗ 𝑔′
(𝑧(𝑙)
), onde o operador “.∗” representa uma

32
multiplicação entre matrizes, elemento por elemento. Essa multiplicação é
apresentada na Figura 10 abaixo, e pode-se observar que 𝐴𝑖𝑗 é multiplicado por 𝐵𝑖𝑗.
Figura 10 Exemplo de multiplicação de matrizes elemento por elemento.
Fonte: Elaborado pelo autor
O algoritmo backpropagation, conforme descrito por Ng (2014), é
apresentado no Quadro 3. Neste algoritmo, a letra delta maiúscula (Δ) é utilizada
para calcular a derivada parcial da função 𝐽, expressa pela Equação 6. Essa matriz é
configurada inicialmente com o valor zero para todos seus elementos.
Quadro 3 Algoritmo Backpropagtion
Para calcular o gradiente de um único exemplo (𝑥(1)
, 𝑡(1)
), em
consonância com o que foi apresentado no Quadro 3, deve-se então seguir os
seguintes passos: realizar a etapa de alimentação da rede usando o vetor 𝑥(1)
; em
seguida, realizar a propagação de retorno usando 𝑡(1)
.
Conjunto de dados {(𝑥(1)
, 𝑡(1)
), … , (𝑥(𝑚)
, 𝑡(𝑚)
)} ;
∆𝑖𝑗
(𝑙)
= 0 (para todo 𝑙, 𝑖, 𝑗);
Para 𝑖 = 1 até 𝑚
𝑎(1)
= 𝑥(1)
;
Calcular 𝑎(𝑙)
para 𝑙 = 2, 3, … 𝐿 ; (forward propagation)
Utilizando 𝑡(𝑖)
, calcule 𝛿(𝐿)
= 𝑎(𝐿)
− 𝑡(𝑖)
;
Calcule 𝛿(𝐿−1)
, 𝛿(𝐿−2)
, … , 𝛿(2)
;
∆(𝑙)
∶= ∆(𝑙)
+ 𝛿(𝑙+1)
(𝑎(𝑙)
)
𝑇
;⏟
(𝑓𝑜𝑟𝑚𝑎 𝑣𝑒𝑡𝑜𝑟𝑖𝑧𝑎𝑑𝑎 𝑑𝑒 𝑐𝑎𝑙𝑐𝑢𝑙𝑎𝑟 ∆ 𝑖𝑗
(𝑙)
)
𝐷𝑖𝑗
(𝑙)
∶=
1
𝑚
∆𝑖𝑗
(𝑙)
;

33
Após a finalização de execução do algoritmo backpropagation, o termo
𝐷𝑖𝑗
(𝑙)
pode ser aplicado ao algoritmo de declínio de gradiente para realizar a
atualização de todos os pesos 𝑊𝑖𝑗
(𝑙)
. Dessa forma, concretiza-se o aprendizado em
redes MLP através do backpropagation.
2.4 Detalhes para implementação de RNAs
2.4.1 Preparação dos dados
Conforme destacado por Marsland (2009, p.63), não só as redes MLP
como também a maioria dos algoritmos de aprendizado de máquina tendem a
aprender mais efetivamente quando algum pré-processamento é desempenhado nas
variáveis de entrada. Esse pré-processamento evita que os pesos sejam ajustados
para valores altos sem necessidade.
Uma forma de pré-processamento realizado nas variáveis de entrada é o
escalonamento de seus respectivos valores. A abordagem mais comum para essa
tarefa é conhecida como Mean Normalization, e seu objetivo é fazer com que todos
os valores sejam normalizados para valores que correspondam à faixa entre -1 e 1
(próximos à zero).
A fórmula para aplicar essa técnica de padronização de variáveis,
considerando a normalização da primeira variável de entrada (𝑥1), é apresentada por
Ng (2014) na Equação 7. Na equação, o termo 𝜇1 refere-se ao valor médio do
atributo 𝑥1 no conjunto de treinamento e o termo 𝑆1 pode representar o intervalo
entre o maior e o menor valor de 𝑥1, também condizente com o conjunto de
treinamento.
𝑥1 =
𝑥1 − 𝜇1
𝑆1
(7)
A Tabela 1 apresenta um simples conjunto de treinamento, apenas para
exemplificação, composto de três exemplos, cada um com duas variáveis. A
primeira variável simboliza o preço de certa compra e a segunda a quantidade de

34
produtos adquirida. Nesta tabela, os valores são apresentados na sua forma pura e
sua última linha corresponde aos cálculos dos termos 𝜇𝑖 e 𝑆𝑖 de cada atributo i.
Tabela 1 Exemplo de um conjunto de treinamento não normalizado.
𝒙 𝟏 (preço) 𝒙 𝟐 (quantidade)
359,00 5
289,00 3
160,00 1
𝜇1= 269,33 𝑆1= 199 𝜇1= 3 𝑆1= 4
Fonte: elaborado pelo autor.
Calculados os termos 𝜇𝑖 e 𝑆𝑖, é possível realizar o escalonamento das
variáveis dos três exemplos, fazendo com que todas fiquem com o mesmo “padrão”.
A Tabela 2 apresenta as variáveis depois de realizados os cálculos de normalização,
e como se pode observar, todas compreendem valores entre -1 e 1.
Tabela 2 Tabela com valores escalonados após uso do Mean Normalization
𝒙 𝟏 (preço) 𝒙 𝟐 (quantidade)
0,45 0.50
0,09 0.00
-0,54 -0.50
A aplicação dessa técnica de escalonamento contribui fazendo com que o
algoritmo de declínio de gradiente convirja com menos iterações (NG, 2014). Dessa
forma, a aprendizagem ocorre de forma mais rápida e eficiente.
2.4.2 Quantidade de dados para treinamento
A definição da quantidade de dados necessários para compor o conjunto
de treinamento, como também será visto no próximo item, é uma questão que faz
parte do contexto da aplicação. Por esse motivo, Marsland (2009, p.64) evidencia
que não existe maneira alguma de se calcular qual a quantidade mínima de dados
requeridos para determinado problema.

35
Uma regra que tem sido utilizada por muito tempo e que pode ser
considerada, de acordo com Marsland (2009, p.64), é de que o conjunto de dados
deve ter o tamanho equivalente a, no mínimo, dez vezes o tamanho dos parâmetros.
Com isso, Marsland (2009, p.64) conclui que provavelmente a quantidade de
exemplos será grande demais, e consequentemente, o treinamento da rede se tornará
uma operação dispendiosa.
Mesmo não existindo uma fórmula matemática que auxilie na
determinação do tamanho do conjunto de dados, Marsland (2009, p.64) descreve
que quanto mais dados, melhor o aprendizado. Entretanto, é valido novamente
salientar que quanto maior a quantidade de dados, maior também será o tempo gasto
para realizar o treinamento da rede.
2.4.3 Arquitetura
Segundo Braga et al. (2004, p.83), “uma das maiores dificuldades em se
definir a estrutura de uma RNA é o fiel dimensionamento de sua topologia”. De
acordo com os autores, é necessária uma análise prévia no conjunto de dados e no
problema em questão, para que assim seja considerado o número de camadas da
rede e a quantidade de neurônios existentes em cada uma delas.
Com relação à escolha do número de camadas ocultas, Braga et al. (2004,
p.70) relatam que “a grande maioria dos problemas práticos raramente necessita de
mais de uma camada intermediária”. Além disso, Braga et al. (2004, p.70) alertam
sobre a seleção de um número de camadas maior que o necessário:
A utilização de um número maior de camadas do que o necessário
pode levar a problemas de convergência da rede, já que as camadas
intermediárias trabalham com estimativas de erro, as quais, quando
em maior quantidade, podem dificultar a convergência global da
rede.
Além de se estabelecer o número de camadas que vai compor a RNA,
também é necessário definir o número de neurônios que serão atribuídos a cada
camada. Essa definição é extremamente importante para o desempenho da rede,
principalmente no que se refere à sua capacidade de generalização, e consiste no

36
problema mais fundamental em aprendizado de redes neurais. (BRAGA et al., 2004,
p.71).
Em conformidade com Braga et al. (2004, p.71), o número de neurônios
está diretamente ligado com a capacidade da rede em solucionar problemas de
determinada complexidade. A relação feita por esses autores é de que “quanto maior
o número de neurônios, maior a complexidade da rede e maior sua abrangência em
termos de soluções possíveis”.
A melhor escolha do tamanho da rede a ser utilizada corresponderá a RNA
que, segundo Braga et al. (2004, p.83), “seja capaz de modelar os dados sem
modelar o ruído contido neles”. Dessa forma, pretende-se que o modelo não seja
muito rígido, a ponto de não modelar fielmente os dados, e também que não seja
excessivamente flexível, a ponto de modelar também o ruído (BRAGA et al., 2004,
p.83).
Mesmo havendo inúmeras abordagens destinadas à determinação do
tamanho da rede, Braga et al. (2004, p.71) constatam que “não existe uma
abordagem que tenha encontrado, formalmente, uma resposta geral para essa
questão fundamental no projeto de redes neurais”. Entretanto, Alpaydin (2010,
p.263) sugere que uma boa ideia para essa escolha é tentar diferentes arquiteturas,
treinar todas elas no conjunto de treinamento, e escolher a que melhor generalizar
no conjunto de validação6
.
2.4.4 Underfitting e Overfitting
Apesar da boa capacidade das RNAs em solucionar problemas complexos
e não lineares, a configuração não adequada de sua estrutura pode resultar em
problemas na sua generalização:
[...] uma das maiores dificuldades em se definir a estrutura de uma RNA é
o fiel dimensionamento de sua topologia. Normalmente, o número de
camadas e o número de neurônios em cada camada são definidos em
função de uma inspeção prévia nos dados e da complexidade do
6
Os conceitos sobre a separação dos dados em conjuntos de treinamento,
validação e teste, são abordados no item 2.4.1.5.

37
problema. Sabe-se, no entanto, que o ajuste inadequado da complexidade
da rede pode levar a efeitos indesejáveis na resposta final do modelo
(BRAGA et al., 2004, p.83).
Os efeitos indesejáveis na generalização da rede, na citação de Braga et al.
(2004, p.83), podem ser compreendidos como as consequências de uma rede que
sofre de problemas de overfitting (superdimensionamento) ou underfitting
(subdimensionamento) (BRAGA et al., 2004, p.83).
Para que uma rede não sofra de overfitting ou underfitting, é necessário
haver um equilíbrio entre o viés (bias) e a variância (flexibilidade7
), obtido através
de seu dimensionamento (BRAGA et al., 2004, p.83). No caso de uma rede
sofrendo de underfitting, o problema está associado ao viés (alta rigidez), por outro
lado, se a rede estiver sofrendo de overfitting, isso simboliza a existência de um
problema de alta variância (NG, 2014).
Outra maneira de compreender a ocorrência desses dois dilemas, expostos
anteriormente, é através da conceituação dada por Alpaydin (2010, p.39). O autor
explica que uma ocorrência de underfitting na rede se dá quando a hipótese ℎ 𝑊( 𝑥) é
menos complexa do que a função subjacente aos dados. E, em um segundo caso, se
a hipótese ℎ 𝑊( 𝑥) for muito complexa, os dados não são suficientes para satisfazê-
la, resultando em uma hipótese ruim.
Figura 11 O efeito do overfitting.
Imaginando a situação em que uma hipótese é muito complexa, o
overfitting ocorrerá porque essa hipótese não só aprenderá a função subjacente aos
7
“Quanto maior a sua estrutura, maior o número de parâmetros livres ajustáveis
e, consequentemente, maior sua flexibilidade” (BRAGA et al., 2004, p.83).

38
dados como também o ruído existente neles (ALPAYDIN, 2010, p.39). Esse
exemplo pode ser observado na Figura 11, onde são apresentados dois gráficos de
diferentes hipóteses para um mesmo conjunto de dados. Na imagem à esquerda, a
linha traçada propõe a hipótese ideal para o problema, e a imagem à direita ilustra o
efeito do problema de superdimensionamento, onde os dados são modelados
perfeitamente, incluindo o ruído; e o resultado disso é uma rede com pouca
capacidade de generalização para novos exemplos.
Quando se tem disponível um conjunto de treinamento muito grande, uma
das formas de contornar o problema de overfitting é separar o conjunto de dados em
dados de treinamento e validação. Dessa forma, é possível utilizar o conjunto de
treinamento para atualização dos parâmetros, e o conjunto de validação para estimar
a capacidade de generalização do modelo. Assim, “o treinamento pode ser
interrompido quando o erro no conjunto de validação começar a subir” (BRAGA et
al., 2004, p.83).
Outra técnica conhecida para evitar overfitting é conhecida como poda
(pruning). Essa técnica visa a retirada de pesos e neurônios irrelevantes para a
hipótese calculada pela rede, porém, ela apresenta a desvantagem de não considerar
a correlação entre eles. Dessa maneira, pode ocorrer que alguma informação
importante para o problema seja retirada de forma errônea (BRAGA et al., 2004,
p.84).
A regularização também tem um papel importante na prevenção de
overfitting e underfitting. Braga et al. (2004, p.84) explicam que esse método
envolve a modificação da função de custo 𝐽 através da adição de termos de
regularização. Com isso, pretende-se, de acordo com Braga et al. (2004, p.84), obter
“soluções com pesos de norma mínima”.
−
1
𝑚
[∑ 𝑡𝑖 log ℎ 𝑊(𝑥𝑖) + (1 − 𝑡𝑖) log(1 − ℎ 𝑊(𝑥𝑖))
𝑚
𝑖=1
] +
𝜆
2𝑚
∑ ∑ ∑ (𝑊𝑗𝑖
(𝑙)
)
2
𝑆 𝑙+1
𝑗=1
𝑆 𝑙
𝑖=1
𝐿−1
𝑙=1⏟
𝐴 𝑟𝑒𝑔𝑢𝑙𝑎𝑟𝑖𝑧𝑎çã𝑜 𝑛ã𝑜 é
𝑎𝑝𝑙𝑖𝑐𝑎𝑑𝑎 𝑎𝑜𝑠 𝑝𝑒𝑠𝑜𝑠
𝑞𝑢𝑒 𝑐𝑜𝑟𝑟𝑒𝑠𝑝𝑜𝑛𝑑𝑒𝑚 𝑎𝑜 𝑣𝑖é𝑠
(8)
A Equação 8 apresenta a adição do termo de regularização à função de
custo apresentada no item 2.3.1. Com ela, é esperado que uma solução com um fiel

39
equilíbrio entre a rigidez e a variância da rede seja obtida, e isso dependerá do
ajuste do parâmetro de regularização 𝜆. Braga et al. (2004, p.84) constatam que
quando o valor de 𝜆 é muito alto “a solução para o vetor de pesos tende para w = 0”,
e por isso, “um valor satisfatório intermediário deve ser encontrado”.
2.4.5 Conjuntos de treinamento, validação e teste
Toda vez que uma rede MLP é treinada, deve ser testado o quão precisa
ela é na predição de novos exemplos. Para isso, deve ser definido um conjunto
próprio destinado apenas para testes. E por que isso? Marsland (2009, p.67) explica
que testar a rede utilizando os mesmos dados utilizados para treinamento não
possibilitará saber se, por exemplo, um problema de overfitting está ocorrendo, nem
mesmo determinar a sua capacidade de generalização.
Conforme visto no parágrafo anterior, existe a necessidade de reservar
parte do conjunto de dados para realização de testes, certificando de que eles não
foram usados para treinamento. A grande desvantagem nesse processo, de acordo
com Marsland (2009, p.67), é de que o conjunto de dados disponível para
treinamento será reduzido, e o autor afirma que não há como escapar disso.
Muitas vezes, além de dividir os dados entre conjunto de treinamento e
conjunto de teste, é necessário também separá-lo em um terceiro conjunto, chamado
de conjunto de validação8
. Esse conjunto é utilizado para verificar quão bem a rede
está aprendendo durante o treinamento (MARSLAND, 2009, p.67).
A proporção de dados utilizados para treinamento, teste e validação é
definida pelo desenvolvedor do projeto. Porém, Marsland (2009, p.67) considera
que na existência de um grande conjunto de dados, a proporção comumente
escolhida é de 50:25:25, e 60:20:20 quando não se possui um conjunto de dados
volumoso.
8
Conhecido como validação cruzada em estatística (MARSLAND, 2009, p.67)

40
Figura 12 O conjunto de dados é dividido em conjunto de
treinamento, teste e validação.
Fonte: adaptado de Marsland (2009, p.67)
Ao realizar a separação dos dados, é necessário se atentar à seguinte
situação descrita por Marsland (2009, p.67):
[...] Como você realiza a divisão também é importante. Muitos conjuntos
de dados são apresentados com o primeiro conjunto de dados pertencendo
a classe 1, o próximo à classe 2, e assim por diante. Se você escolher os
primeiros dados para o conjunto de treinamento, os próximos para o
conjunto de teste, etc. os resultados serão muito ruins, já que o
treinamento não conhecerá todas as classes. (MARSLAND, 2009, p.67).
Para contornar o problema descrito no parágrafo anterior, o próprio autor
recomenda que, ou primeiramente o conjunto de dados seja aleatoriamente
reordenado, ou que seja atribuído cada par ( 𝑥, 𝑦) aleatoriamente para cada um dos
conjuntos (MARSLAND, 2009, p.67). Essa segunda proposta de divisão dada por
Marsland (2009, p.67) é ilustrada na Figura 12.
2.4.6 Avaliação de resultados
O treinamento de redes neurais MLP requer que o algoritmo seja
executado sobre o todo o conjunto de dados muitas vezes, modificando os pesos da
rede de acordo com os erros cometidos pela rede a cada iteração (MARSLAND,
2009, p. 68). Finalizado o treinamento, é necessário avaliar e analisar os resultados
correspondentes ao desempenho da rede, e para isso, deve ser utilizado o conjunto
de teste.

41
O desempenho da rede pode ser avaliado através da comparação entre a
predição realizada pela rede e os seus alvos correspondentes. Para o problema de
classificação, é possível calcular a quantidade de vezes que a rede conseguiu
predizer corretamente cada classe, e assim, determinar a precisão de predição da
rede (MARSLAND, 2009, p.69).
Para exemplificar o cálculo de precisão de uma rede MLP configurada
para um problema de classificação, imagina-se que um teste seja realizado em um
conjunto com 1200 exemplos. Depois de realizado esse teste e, caso constatado que
1089 predições foram bem sucedidas, é possível determinar através da Equação 9
que a rede tem uma precisão de 90,75%.
𝑝𝑟𝑒𝑑𝑖çõ𝑒𝑠 𝑐𝑜𝑟𝑟𝑒𝑡𝑎𝑠
𝑛º 𝑑𝑒 𝑝𝑟𝑒𝑑𝑖çõ𝑒𝑠 𝑟𝑒𝑎𝑙𝑖𝑧𝑎𝑑𝑎𝑠
∗ 100 (9)
Concluído os testes na RNA desenvolvida, o próximo passo é avaliar
possíveis melhorias a serem implementadas para aumentar a precisão de predição da
rede. De acordo com Ng (2014), algumas das medidas que podem ser tomadas nessa
etapa, em qualquer sistema de aprendizado de máquina, são listadas a seguir:
 Coletar mais exemplos para treinamento;
 Tentar utilizar uma menor quantidade de atributos;
 Tentar adicionar mais atributos;
 Tentar aumentar o valor do parâmetro de regularização 𝜆;
 Tentar diminuir o valor de 𝜆;
Com exceção do primeiro item, todos os outros podem ser melhores
determinados utilizando algoritmos de seleção de modelo. Esse método é o mesmo
recomendado por Alpaydin (2010, p.263) na escolha da arquitetura da RNA,
fazendo-se necessário a existência do conjunto de validação.
2.4.7 Curva de aprendizado
Uma das medidas apresentadas por Ng (2014) que pode influenciar
positivamente nos resultados de um sistema de aprendizado de máquina é adquirir

42
mais dados para treinamento da rede. Porém, essa tarefa só irá ajudar caso o
algoritmo não esteja sofrendo com problemas de alta rigidez (NG, 2014).
A maneira de verificar se a coleta de mais dados auxiliará no desempenho
da rede é gerar um gráfico conhecido como curva de aprendizado. Nesse gráfico,
uma curva é apresentada mostrando a variação do erro da rede de acordo com o
aumento do número de exemplos utilizados no treinamento. Com isso é possível
identificar se a coleta de mais dados será viável ou não.
Figura 13 Exemplo de curva de aprendizado.
Um exemplo de curva de aprendizado, descrita por Ng (2014), é
apresentada na Figura 13, onde o eixo y corresponde ao erro calculado pela rede e o
eixo x corresponde ao tamanho do conjunto de dados utilizado para o treinamento.
Nessa figura, é possível observar que quanto maior a quantidade de exemplos
utilizado no treinamento, maior o erro calculado pela função de custo 𝐽 no conjunto
de treinamento, e menor o valor do erro calculado pela função de custo no conjunto
de validação, o que simboliza que coletar mais dados de treinamento pode melhorar
os resultados.

43
Figura 14 Segundo exemplo de curva de aprendizado.
Os autores Russell e Norvig (2009, p.703) apresentam na Figura 14 outra
proposta de curva de aprendizado, onde o gráfico representa a relação de “precisão
da rede x número de exemplos utilizados para treinamento”. Neste caso, a rede é
treinada utilizando o conjunto de treinamento, e sua precisão é avaliada no conjunto
de teste.
Através da curva de aprendizado de Russell e Norvig, é possível observar
que quanto maior o tamanho do conjunto de treinamento, maior a precisão da rede
calculada no conjunto de teste. Logo, se o conjunto de treinamento fosse composto
apenas de 20 exemplos, através dessa curva poderia constatar o efeito positivo de
coletar mais exemplos, a fim de atingir quase 100% de precisão.
Apesar de abordarem relações diferentes, as curvas de aprendizado
apresentadas anteriormente, tanto na Figura 13 quanto na Figura 14, são boas
ferramentas para auxiliar a detectar se existe a necessidade ou não de coletar mais
dados de treinamento.
2.5 Octave
As linguagens de prototipação mais comuns, utilizadas no contexto de
aprendizado de máquina, são: Octave, MATLAB, Python, NumPy e R (NG, 2014).

44
Dentre essas, a escolhida para prototipação do sistema foi o Octave, que além de ser
considerada uma ótima ferramenta para esse propósito (NG, 2014), é um software
gratuito e de código aberto (Open Source).
Figura 15 Interface de linha de comando do Octave.
Fonte: print screen do software no sistema operacional Windows 8
O GNU Octave é uma linguagem de alto nível, escrito inicialmente por
John W. Eaton, destinado principalmente para computação numérica. Possui uma
interface de linha de comando (Figura 15) para solução de problemas
numericamente lineares e não lineares, e para execução de experimentos numéricos.
Além disso, ele é livremente redistribuído, sendo um software livre sob os termos
da licença GNU General Public License (GPL) (EATON, 2013).
O Octave é compatível com o MATLAB, possuindo a sintaxe e um grande
número de funções semelhantes. Também possui ferramentas extensivas para
resolução de problemas lineares numéricos comuns em álgebra, cálculo aproximado
de raízes de equações não lineares, funções ordinárias, polinômios, cálculo de
integrais, entre outros; visto que sua expansão e customização é algo que pode ser
facilmente realizado através de funções definidas pelo utilizador na própria
linguagem Octave, ou fazendo uso de módulos dinamicamente carregados escritos
em C++, C, Fortran, ou outras linguagens (EATON, 2013).
Outra grande vantagem pertinente a linguagens de prototipação, como por
exemplo, o Octave, é de que elas possuem diferentes bibliotecas de álgebra linear
numérica. O uso dessas bibliotecas possibilitam códigos mais eficientes e mais

45
rápidos de serem executados, além de reduzir o código necessário para escrita,
tornando-o mais simples. Por exemplo, ao invés de escrever um código com laços
(loops) para realizar uma multiplicação entre duas matrizes A e B, basta
simplesmente utilizar o comando “A*B” na linha de comando do Octave e o
resultado esperado será apresentado (NG, 2014).
2.5.1 Operações básicas
Com o objetivo de facilitar a compreensão dos códigos que serão vistos
posteriormente no item 3.2, é importante apresentar a forma como algumas
operações se comportam na sintaxe do Octave. O Quadro 4 apresenta a forma como
expressões aritméticas são escritas nessa linguagem, exemplificando a sintaxe para
as operações de soma, subtração, multiplicação, divisão e potenciação.
Quadro 4 Expressões aritméticas no Octave
Expressão Resultado
5 + 6 11
3 − 2 1
5 ∗ 8 40
1/2 0.5
2^6 11
O Quadro 5 lista os principais operadores responsáveis pela construção de
expressões lógicas dentro do Octave. Essas expressões lógicas sempre retornarão os
valores um ou zero, que respectivamente significam “verdadeiro” ou “falso”. No
Octave, o operador que verifica se uma variável é diferente de outra, também pode
ser representado pelo sinal “!=”, normalmente utilizado em outras linguagens, como
por exemplo, o Java.

46
Quadro 5 Operadores lógicos no Octave
Operador Descrição
== Igualdade
~ = Diferente
> Maior
< Menor
&& “E” lógico
|| “OU” lógico
Para compreender a maneira como se declara variáveis no Octave (vetores
e matrizes) é utilizado o Quadro 6, que simula a interface fornecida pelo programa.
Observa-se que, na declaração da matriz A, os valores são digitados de forma
sequencial e é utilizado o ponto e vírgula (;) quando existe a necessidade de definir
uma nova linha na matriz. Pode-se analisar também que, ao suprimir o ponto e
vírgula após a declaração ou atribuição de uma variável, a sua saída é apresentada.
Quadro 6 Declaração de variáveis no Octave.
Os comandos IF, FOR, e WHILE (controle de fluxo dos algoritmos) são
similares às sintaxes utilizadas em outras linguagens como C ou Pascal (Quadro 7).
>> a = 3;
>> b = 'hi';
>> c = 3>=1
c = 1
>>
>> v = [1 2 3];
>>
>> A = [1 2; 3 4; 5 6]
A =
1 2
3 4
5 6

47
Quadro 7 Exemplo de comandos FOR, WHILE e IF no Octave
2.5.2 Funções
Para criar uma função, escreve-se a função em qualquer editor de texto,
como por exemplo, gedit ou notepad, e salvar o arquivo como “nomedafuncao.m”.
Uma peculiaridade das funções do Octave é que elas podem retornar mais do que
um valor (Quadro 10), diferentemente de outras linguagens de programação.
Quadro 8 Exemplo de função que calcula o quadrado de um número.
Para chamar a função criada, utiliza-se o comando cd seguido do caminho
onde a função está localizada, e digitar o seu nome passando o parâmetro desejado
entre os parênteses (Quadro 9).
>> v = [1 2 3 4 5];
>> for i=1:5
> v(i) = v(i)^2;
> end
>>
>> i = 1;
>> while i <= 5
> v(i) = 100;
> i = i+1;
> end
>>
>> if v(1)==1
> disp('valor igual a 1');
> elseif v(1)==2
> disp('valor igual a 2');
> else
> disp('valor diferente de 1 e 2!');
> end
function resultado = quadrado(x)
resultado = x^2;

48
Quadro 9 Exemplo de chamada de função.
Quadro 10 Função que retorna mais de uma variável.
2.5.3 Vetorização
Conforme observado no início desse capítulo, o Octave possui bibliotecas
especiais para que o conceito de vetorização possa ser aplicado (NG, 2014). O
processo de vetorização consiste basicamente em converter códigos compostos por
loops através de operações de matrizes.
Para exemplificar esse processo, o Quadro 11 apresenta a forma não
vetorizada de se calcular a hipótese ℎ 𝜃(𝑥) = ∑ 𝜃𝑗 𝑥𝑗
𝑛
𝑗=0 , onde 𝜃 e 𝑥 são vetores.
Neste caso, o código é desenvolvido utilizando um laço de repetição para realizar o
cálculo. O mesmo cálculo é implementado de maneira diferente no Quadro 12, e
representa a versão vetorizada, com apenas uma linha de código.
Quadro 11 Exemplo de implementação não vetorizada.
>> cd /Users/Bruno/Octave/Funcoes
>> quadrado(2)
ans = 4
function [a, b] = quadradoeCubo(x)
a = x^2;
b = x^3;
end
>> hipotese = 0.0;
>>
>> for j = 1:n+1,
>> hipotese += theta(j) * x(j);
>> end;
>>

49
Quadro 12 Exemplo de implementação vetorizada
O apóstrofo é utilizado para obter a transposta de uma matriz. Essa
operação é demonstrada de forma detalhada no Quadro 13, onde a matriz B recebe a
transposta da matriz A.
Quadro 13 Obtendo a transposta de uma matriz.
Figura 16 Exemplo de multiplicação de matrizes.
Fonte: Ribeiro (2014)
Considerando a definição de multiplicação de matrizes (Figura 16), é
possível verificar que a versão vetorizada do cálculo da hipótese ℎ 𝜃(𝑥) realiza o
somatório da multiplicação de elemento por elemento, entre 𝜃 e 𝑥, com uma
notação muito concisa. Para fazer isso, essa única linha de código utiliza rotinas de
álgebra linear numérica do Octave altamente otimizadas (NG, 2014).
>> hipotese = theta' * x;
>>
>> A = [1 2; 3 4; 5 6]
A =
1 2
3 4
5 6
>>
>> B = A'
B =
1 3 5
2 4 6

50
3 DESENVOLVIMENTO
Neste capítulo são apresentados a maneira como foi construído o conjunto
de dados, os códigos desenvolvidos para implementação da RNA e os resultados e
conclusões obtidas. A aplicação desenvolvida faz uso do algoritmo backpropagation
para realizar o treinamento da rede e, posteriormente, utiliza os parâmetros
ajustados para predizer, em uma seleção de imagens, quais são adequadas para uso
no perfil do LinkedIn.
Os algoritmos desenvolvidos em Octave, na sua versão 3.2.4, foram
executados em um computador Intel Core i5 M460 com processador de 2.53GHz e
4GB de memória RAM (Random Access Memory). O desenvolvimento foi
sequenciado da seguinte maneira:
1. Selecionar os vetores de entrada e alvo para o problema;
2. Normalizar as variáveis de entrada;
3. Dividir os dados em conjunto de treinamento, validação e teste;
4. Selecionar a arquitetura da rede;
5. Treinar a rede;
6. Testar a rede;
3.1 Funcionamento do sistema
O protótipo foi desenvolvido sobre a ferramenta GNU Octave versão 3.2.4
e por esse motivo, todas suas funcionalidades são acessadas através de uma
interface de linha de comando. Um menu foi criado para auxiliar a execução das
seguintes tarefas implementadas no software: criação do conjunto de dados,

51
treinamento da rede neural artificial, avaliação da precisão da rede na generalização
de novos exemplos e classificação de fotos específicas.
Figura 17 Tela inicial do protótipo
Fonte: print screen do software no sistema operacional Windows 8
O processo de desenvolvimento do protótipo, a explanação do seu
funcionamento e os códigos utilizados são apresentados nos parágrafos seguintes.
No item 3.5 são abordados os testes e resultados obtidos com o protótipo
construído.
3.1.1 Criação do conjunto de dados
Para criação do conjunto de dados a ser utilizado no projeto, foi realizada
uma seleção manual de fotos disponíveis na internet. Depois de baixadas, as fotos
foram separadas em dois diretórios diferentes, levando em consideração os aspectos
condizentes com uma foto adequada para exibição no perfil do LinkedIn, listados no
item 1.3. As fotos consideradas boas foram movidas para a pasta nomeada por
“Fotos válidas”, e as que representavam exemplos de fotos ruins, foram colocadas
na pasta “Fotos inválidas”.

52
Figura 18 Exemplos de fotos utilizadas em perfis do LinkedIn
Fonte: Elaborada pelo autor
Para iniciar a implementação da RNA, foram coletadas cerca de 2.500
imagens, e ao fim do projeto essa quantidade totalizou pouco mais de 10.000 fotos.
Na Figura 18 é possível observar alguns exemplos de fotos utilizadas no perfil do
LinkedIn. As fotos (a) e (b) não são apropriadas pelo fato de não ser possível
visualizar o rosto dos usuários, ao contrário do que pode ser observado nas fotos (b)
e (c).
Após a concepção das duas pastas contendo centenas de exemplos de
fotos, o próximo passo foi transformar essas imagens em dados possíveis de serem
trabalhados dentro do Octave. Para isso, criou-se uma função chamada
“createDataset.m” que, de forma geral, gera um arquivo contendo uma matriz X e
um vetor y com os exemplos e alvos respectivos (0 - fotos inválidas; 1 - fotos
válidas). Portanto, concluída essa etapa, o conjunto de dados para alimentar a rede
neural estará configurado.
O comando utilizado no Octave para realizar a leitura em pixels de
determinada imagem é o imread (linha 8). No Quadro 14 é possível analisar parte
do código da função createDataset.m. Neste trecho de código é realizada a leitura
de todas as imagens contidas no diretório Fotos válidas através de um laço de

53
repetição.
Quadro 14 Parte da função createDataset.m.
1 cd 'Dados/Fotos válidas';
2 X = ones(1,dimension);
3
4 images = dir ("*");
5 for i = 3:length (images)
6 try
7 photos = [photos; images(i).name];
8 img = imread(images(i).name);
9 img = adjustImage(img,width,height);
10 img = double(img);
11 X = [X; img];
12 catch
13 fprintf(images(i).name);
14 lasterror.message
15 fflush(stdout);
16 end_try_catch
17 end
18 X = X(2:size(X,1),:);
19 y = ones(size(X,1),1);
A linha 9 faz a chamada da função responsável por fazer o pré-
processamento da imagem. Feito esse processo, a imagem é adicionada a matriz X
como um novo exemplo a ser utilizado. A linha 18 serve para retirar a primeira linha
da matriz X, que contém todos os valores igual a 1 e serviu apenas para inicialização
da variável. A linha 19 cria um vetor com todos os elementos igual a 1, que
corresponde às saídas desejadas para cada exemplo “válido” adicionado na matriz
X.
O Quadro 15 apresenta a função adjustImage.m, onde a linha 5
corresponde à conversão para a escala de cinza9
, a linha 2 ao redimensionamento
para dimensões padrão e a linha 8 ao redesenho da matriz de pixel em uma única
linha10
. Feito isso, é retornado o vetor com os valores dos atributos do exemplo
9
Na linha 4 é verificado primeiramente se a imagem não está na escala de cinza,
para que assim possa ser feita a conversão.
10
A função reshape, como apresentada no Quadro 15, transforma a matriz em
um vetor. Se a matriz tem dimensões 25x25, ela será transformada em um vetor
de tamanho 1x625.

54
atual.
Quadro 15 Função adjustImage.m.
1 function img = adjustImage(image,width,height)
2 img = imresize(image,[width height]);
3
4 if (size (img, 3) == 3)
5 img = rgb2gray(img);
6 endif
7
8 img = reshape(img,[1 width*height]);
9 end
Figura 19 À direita, o efeito causado pela função adjustImage.m.
Fonte: print screen do Octave no sistema operacional Windows 8
Para realizar o carregamento das fotos inválidas, o mesmo processo é
repetido. Entretanto, desta vez é adicionado ao vetor y uma quantidade n de
elementos com valor igual a zero. Essa quantidade n equivale ao número de fotos
inválidas existente na pasta Fotos inválidas e consequentemente adicionadas a
matriz X.
Depois que a matriz X recebe todos os exemplos das duas pastas de dados
e o vetor y é configurado com o valor alvo de cada elemento xi, é realizado o
procedimento de escalonamento dos atributos, utilizando Mean Normalization.
Normalizados os atributos, a matriz X e o vetor y são divididos entre os conjuntos

55
de treinamento, validação e teste (X, Xval, Xtest, y, yval, ytest), de acordo com a
proporção desejada.
As variáveis definidas nessa função são gravadas em um arquivo nomeado
por “dataset.mat”. Esse tipo de arquivo (.mat) armazena dados em binário (não
legíveis por humanos) e é um formato interno do MATLAB (THE MATHWORKS
INC, 2014). Dessa forma, em qualquer momento pode ser utilizado o comando load
para carregar as variáveis desse arquivo para o ambiente do Octave.
Figura 20 Apresentação de parte dos dados de entrada da rede.
A Figura 20 ilustra o carregamento do arquivo dataset.mat e depois, para
facilitar a visualização, apresenta apenas os cinco primeiros atributos dos cinco
primeiros exemplos do conjunto de treinamento, representado pela matriz X. Em
seguida são apresentados os valores “alvo” desses cinco exemplos que, conforme
observado, correspondem a fotos adequadas.
3.1.2 Arquitetura da RNA
Conforme descrito no item 2.4.3, a definição da arquitetura da rede MLP é
uma das partes mais difíceis no desenvolvimento de um sistema de aprendizado de
máquina utilizando essa técnica. As camadas de entrada e de saída são facilmente
determinadas através da quantidade de atributos que compõem cada elemento xi e
quantidade de classes existentes yi para o problema; todavia, projetar as camadas

56
ocultas da rede é considerado uma arte (NIELSEN, 2014).
Figura 21 Arquitetura inicial da RNA do projeto.
Fonte: Elaborada pelo autor
De acordo com Ng (2014), utilizar apenas uma camada oculta é um
padrão razoável e mais comumente aplicado. Por conseguinte, a arquitetura da RNA
do projeto, definida inicialmente, foi projetada conforme ilustrada na Figura 2011
. A
camada oculta foi composta por 25 neurônios, enquanto a camada de saída possuiu
apenas uma unidade (classificação binária).
O algoritmo de seleção de modelos, para tentar encontrar o tamanho ideal
de nós para a camada oculta, foi desenvolvido, porém, pela quantidade razoável de
dados coletados, não se obteve um desempenho relevante para seu uso no
treinamento. Por esse motivo, foi adotado o método de tentativas com diferentes
arquiteturas, realizando o treinamento com a união do conjunto de treinamento e de
validação criados, e fazendo os testes no conjunto de teste. Os resultados são
apresentados no item 3.2.4.
3.1.3 Treinamento da RNA
Definidos o conjunto de dados para treinamento e a arquitetura da rede, é
possível dar início ao desenvolvimento do algoritmo de treinamento da RNA. O
11
Neste desenho, o viés foi desconsiderado, porém é adicionado no treinamento.

57
treinamento baseou-se no algoritmo backpropagation, utilizado para resolução de
problemas não lineares através de redes MLP.
Quadro 16 Inicialização do algoritmo de treinamento.
1 % Inicialização
2 clear ; close all; clc
3
4 fprintf('Carregando e visualizando os
dados...n')
5 fflush(stdout);
6 load dataset.mat;
7
8 % Variaveis
9 input_layer_size = size(X,2); % Camada de entrada
10 hidden_layer_size = 25; % Camada intermediária
11 output_layer_size = 1; % Camada de saída
12 image_height = image_width =
sqrt(input_layer_size);
% largura e altura da imagem
13 lambda = 0.16; % parâmetro de regularização
14
15 X = [X; Xval];
16 y = [y; yval];
Figura 22 Comando whos executado após inicialização do algoritmo.

58
A parte de inicialização do algoritmo é apresentada no Quadro 16, onde as
variáveis necessárias são declaradas e os dados são carregados no sistema. Como a
quantidade de dados coletados não é suficiente para utilização de algoritmos de
seleção de modelo, o conjunto de validação é agregado ao conjunto de treinamento
(linhas 15 e 16) para melhorar a precisão dos resultados. Com o comando whos é
possível identificar, de forma detalhada, as informações das variáveis definidas no
escopo atual. A Figura 21 mostra todas as variáveis que foram carregadas após a
inicialização do algoritmo.
Depois de inicializadas as variáveis essenciais para execução do
treinamento da rede, a função que realiza esse treinamento é chamada. Nesta
função, os parâmetros da primeira e segunda camada da rede são declarados e
inicializados (Theta1 e Theta2). Como visto no item 2.3.3, esses parâmetros são
inicializados com valores aleatórios na faixa entre −𝜀 e −𝜀, e o Quadro 17
demonstra a função utilizada para essa tarefa. Dessa forma, assegura-se que os
parâmetros tenham baixos valores, aumentando a eficiência do aprendizado.
Quadro 17 Função de inicialização dos parâmetros da RNA
1 function W = randInitializeWeights(L_in, L_out)
2 epsilon_init = 0.12;
3 W = rand(L_out, 1 + L_in) * 2 * epsilon_init - epsilon_init;
4
5 end
O backpropagation é implementado na função nnCostFunction.m, que
além de calcular os gradientes dos parâmetros Theta1 e Theta2, também calcula o
custo J em relação a esses parâmetros. Essa função (Quadro 18) recebe duas
matrizes correspondentes aos parâmetros Theta1 e Theta2 rearranjadas12
em um
único vetor. E por esse motivo, as linhas 2 e 4 executam o comando reshape para
que os parâmetros possam voltar para sua forma original.
As linhas de 6 a 9 fazem a inicialização de algumas variáveis úteis e a
12
O rearranjo das matrizes de parâmetros para um único vetor, através do
comando reshape, é realizado por causa da forma como os algoritmos de
otimização avançados trabalham para minimizar a função de custo.

59
linha 10 adiciona uma coluna com valor 1 a cada exemplo do conjunto de
treinamento, correspondente ao viés (bias input). O restante do algoritmo é
apresentado no Quadro 19, com a implementação das fases forward e backward,
além do cálculo do custo J para cada exemplo x.
Quadro 18 Parte I da função nnCostFunction.m.
1 Function [J grad] = nnCostFunction(nn_params,input_layer_size, ...
hidden_layer_size, ...
num_labels, X, y, lambda)
2 Theta1 = reshape(nn_params(1:hidden_layer_size * (input_layer_size + 1)),
hidden_layer_size, (input_layer_size + 1));
3
4 Theta2 = reshape(nn_params((1 + (hidden_layer_size * (input_layer_size +
1))):end), num_labels, (hidden_layer_size + 1));
5
6 m = size(X, 1);
7 J = 0;
8 Theta1_grad = zeros(size(Theta1));
9 Theta2_grad = zeros(size(Theta2));
10 X = [ones(m, 1) X];
11 % continuação no Quadro 19
Com exceção do laço de repetição utilizado para iterar sobre o conjunto de
treinamento, todo o resto do código é desenvolvido de forma vetorizada. Para cada
exemplo x nos m exemplos, executa-se a etapa de propagação das entradas,
descritas entre as linhas 20 a 23.
Quadro 19 Implementação do Backpropagation
19 for i = 1:m
20 a1 = X(i,:);
21 z2 = a1 * Theta1';
22 a2 = [ones(1) sigmoid(z2)];
23 h = sigmoid(a2 * Theta2');
24 d3 = (h - y(i));
25 d2 = (Theta2' * d3')';
26 d2 = d2(:,2:end) .* sigmoidGradient(z2);
27 Theta1_grad = Theta1_grad + d2' * a1;
28 Theta2_grad = Theta2_grad + d3' * a2;
29 J = J + sum(-y(i) * log(h)'- (1-y(i)) * log(1-h)');
30 end
31 % continua no Quadro 20

60
Na linha 22, observa-se que é adicionado uma coluna de 1 na camada
oculta, que simboliza o viés dessa camada. Por conseguinte, a linha 23 calcula a
hipótese h do exemplo atual, que em seguida é utilizada para calcular o erro em
relação à saída desejada y.
Depois de executada a propagação, a linha 24 computa o erro na última
camada através de d3, e então é retropropagado o erro para a camada anterior d2
(linha 26). A linha 26, por sua vez, calcula o erro de cada nó na camada oculta, com
exceção ao neurônio que representa o viés, já que esse não possui erro associado a
ele. E a função sigmoidGradient.m é utilizada para calcular o gradiente da função
sigmoide.
Na linha 29 é calculada parte da função J que é utilizada posteriormente
para encontrar parâmetros Theta1 e Theta2 que minimizem essa função de custo. A
fórmula dentro do somatório sum simboliza quão bem a rede está desempenhando
nesse determinado exemplo i. Calculando a função de custo, algoritmos como o
declínio de gradiente ou ainda, algoritmos de otimização, podem ser utilizados para
encontrar os valores ideais para os parâmetros Theta1 e Theta2.
Quadro 20 Cálculo da função de custo e gradientes dos parâmetros
Theta1 e Theta2 com regularização.
32 J = sum(J)/m;
33
34 reg = (lambda/(2*m)) * ( sum(sum(Theta1(:,2:end).^2)) +
sum(sum(Theta2(:,2:end).^2)));
35 J = J + reg;
36
37 regTerm1 = (lambda/m) .* Theta1(:,2:end);
38 regTerm2 = (lambda/m) .* Theta2(:,2:end);
39
40 Theta1_grad = (Theta1_grad/m) + regTerm1;
41 Theta2_grad = (Theta2_grad/m) + regTerm2;
42
43 grad = [Theta1_grad(:) ; Theta2_grad(:)];
44
45 end
O Quadro 20 apresenta o restante da função J adicionando o termo de

61
regularização (linha 35), conforme expresso na Equação 8 (item 2.4.4). O cálculo
do gradiente dos parâmetros Theta1 e Theta2, também regularizados, são escritos
nas linhas 40 e 41 desse mesmo quadro. Por fim, a última variável que precisa ser
atribuída, como retorno da função, é a variável grad, que retorna as matrizes
Theta1_grad e Theta2_grad rearranjadas em um único vetor (linha 43).
Para cálculo de atualização dos parâmetros da rede, ao invés de utilizar o
algoritmo de declínio de gradiente, conforme visto no capítulo 2, foi determinada a
utilização de um algoritmo de otimização avançado. Esse tipo de algoritmo possui
rotinas otimizadas que aumentam a rapidez de convergência e também são mais
apropriados quando o problema é muito grande, contendo muitos atributos (NG,
2014). Além disso, eliminam a necessidade de manualmente determinar um valor
para o parâmetro α, correspondente à taxa de aprendizagem.
O Quadro 21 apresenta a chamada do algoritmo de otimização avançado
fmincg, responsável por retornar os valores atualizados dos parâmetros Theta1 e
Theta2 e o custo final. Depois de atualizados, esses parâmetros são utilizados para
predição das classes dos exemplos no conjunto de teste.
Quadro 21 Chamada da função fmincg.m.
1 initial_Theta1 = randInitializeWeights(input_layer_size, hidden_layer_size);
2 initial_Theta2 = randInitializeWeights(hidden_layer_size, output_layer_size);
3
4 initial_nn_params = [initial_Theta1(:) ; initial_Theta2(:)];
5
6 options = optimset('MaxIter', 500);
7 costFunction = @(p) nnCostFunction(p, input_layer_size, hidden_layer_size,
output_layer_size, X, y, lambda);
8
9 [nn_params, cost] = fmincg(costFunction, initial_nn_params, options);
Como se pode observar, a função fmincg.m recebe como primeiro
parâmetro, um ponteiro que aponta para a função nnCostFunction.m (Quadro 18,
Quadro 19 e Quadro 20). Os outros dois parâmetros são os valores iniciais dos
parâmetros Theta1 e Theta2, rearranjados no vetor initial_nn_params (linha 4), e a
quantidade máxima de iterações (épocas) a serem executadas, definidas pelo

Reconhecimento de fotos para LinkedIn usando RNA

Reconhecimento de fotos para LinkedIn usando RNA

Recomendados

Recomendados

Mais conteúdo relacionado

Destaque

Destaque (7)

Semelhante a Reconhecimento de fotos para LinkedIn usando RNA

Semelhante a Reconhecimento de fotos para LinkedIn usando RNA (20)

Reconhecimento de fotos para LinkedIn usando RNA