TCC-BrunoAzevedoCosta

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., 2007, 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.,

2007, 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., 2007, p. 4). Seu objetivo,

conforme descrito por Braga et al. (2007, 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. (2007, 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., 2007, p.5).

As RNAs, consoante com Braga et al. (2007, 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. (2007, 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., 2007, p.18).

Em conformidade com o que foi exposto por Braga et al. (2007, 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., 2007, 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. (2007, 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., 2007, 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., 2007, 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. (2007, 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., 2007, p.12).

Entre os principais paradigmas de aprendizado mencionados por Braga et

al. (2007, 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. (2007, 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., 2007, 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., 2007, 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., 2007, 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., 2007, p.67).

De acordo com Braga et al. (2007, p.67), é possível identificar a existência

de um problema relacionado às redes de múltiplas camadas. Braga et al. (2007,

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


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

62

parâmetro options (linha 6).

Assim que é obtido o vetor nn_params, depois da execução do algoritmo

fmincg, esse pode ser utilizado para testar a qualidade do treinamento da rede no

conjunto reservado para teste. Dessa forma, conclui-se a etapa de treinamento da

rede e o algoritmo para teste da rede é apresentado a seguir.

3.1.4 Avaliação do treinamento

Neste momento, o vetor nn_params contendo os valores de Theta1 e

Theta2, que minimizam a função de custo J, já está disponível. O próximo passo é

voltá-los para sua forma original (linhas 1 e 2) e utilizá-los para verificar a

qualidade de treinamento da rede. Para isso, foi desenvolvido o código apresentado

no Quadro 22.

Quadro 22 Exibindo os resultados de desempenho do treinamento

1 Theta1 = reshape(nn_params(1:hidden_layer_size * (input_layer_size + 1)), hidden_layer_size, (input_layer_size + 1));

2 Theta2 = reshape(nn_params((1 + (hidden_layer_size * (input_layer_size + 1))):end), output_layer_size, (hidden_layer_size + 1));

3

4 Xtest = sortByCol(Xtest,ytest);

5 ytest = sort(ytest,'descend');

6

7 qtdeFotosBoas = sum(ytest == 1);

8 [pred pVal] = predict(Theta1, Theta2, Xtest);

9 pred_wrong = find(pred != ytest);

10 acc = mean(double(pred == ytest)) * 100;


As linhas 4 e 5, por conveniência, realizam a ordenação dos elementos do

conjunto de teste de acordo com a sua respectiva classe y e de forma decrescente. A

linha 8 utiliza os parâmetros Theta1 e Theta2 treinados pela rede, para “adivinhar” a

quais classes pertence cada um dos exemplos em Xtest (conjunto de exemplos

reservado para teste). A linha 10 calcula a porcentagem de acerto da rede na

generalização de novos exemplos, que pode ser compreendido como o índice de

precisão da RNA.

A função predict.m (Quadro 23) retorna dois vetores p e h2 contendo,

63

respectivamente, a classe “adivinhada” e o valor exato calculado pela hipótese

hθ(x) para cada exemplo i do conjunto de teste. O processo para calcular essa

hipótese é equivalente a etapa de alimentação da rede, vista na fase de treinamento,

onde os sinais de entrada (atributos de cada exemplo) são propagados, realizando a

ativação das unidades nas camadas posteriores, até se obter a o valor de saída

calculado por hθ(x) (linhas 6 e 7). Se esse valor de saída for maior que “0,50”, o

exemplo é classificado como “válido”, caso contrário, é classificado como

“inválido” (linha 8).

Quadro 23 Função predict.m.

1 function [p h2] = predict(Theta1, Theta2, X)

2 3 m = size(X, 1);

4 p = zeros(size(X, 1), 1);

5 6 h1 = sigmoid([ones(m, 1) X] * Theta1');

7 h2 = sigmoid([ones(m, 1) h1] * Theta2');

8 p = h2 > 0.50;


Concluída a predição de todos os exemplos em Xtest, os resultados de

desempenho são gravados em um arquivo de texto nomeado por results.txt. Nele são

registradas informações referentes à arquitetura utilizada, quantidade de atributos,

valor escolhido para o parâmetro de regularização λ, precisão, quantidade de

predições erradas, quantidade de fotos “válidas” classificadas incorretamente,

quantidade de fotos “inválidas” classificadas incorretamente, etc.

3.1.5 Curva de aprendizado

Para avaliar a necessidade de adquirir mais exemplos para treinamento

com o propósito de melhorar os resultados obtidos durante determinado teste, foi

desenvolvido um algoritmo para geração da curva de aprendizado. Esse algoritmo é

descrito no Quadro 23.

Neste quadro, as linhas de 1 a 4 representam a declaração das variáveis a

serem utilizadas. O procedimento, conforme pode ser observado (linhas 6 a 13),

64

consiste em, a cada iteração, realizar o treinamento com um número j de exemplos

(aumentando-o gradativamente); e utilizar os parâmetros aprendidos para calcular o

custo da rede em relação ao conjunto utilizado para treinamento e em relação a um

conjunto teste (ainda não conhecido pela rede).

Depois de finalizada a iteração estabelecida pela linha 6, obtém-se as

variáveis error_train e error_val contendo os erros calculados para cada intervalo

com 100 exemplos adicionados ao conjunto de treinamento. Com esses dados, é

possível, através da linha 15, exibir o gráfico que possibilita visualizar se o aumento

de exemplos no conjunto de treinamento influenciará positivamente no resultado

obtido.

Quadro 24 Código de Geração da curva de aprendizado

1 m = size(X, 1);

2 loop = m/100;

3 error_train = zeros(loop, 1);

4 error_val = zeros(loop, 1);

5 6 for i = 1:loop

7

j=i*100;

8 9

theta = runTraining(X(1:j,:),y(1:j),lambda,i_size,h_size,o_size);

10 11

error_train(i) = nnCostFunction(theta,i_size,h_size,o_size,X(1:j,:),y(1:j),0);

12

error_val(i) = nnCostFunction(theta,i_size,h_size,o_size,Xval,yval,0);

13 end 14

15 plot(1:loop, error_train, 1:loop, error_val);

16 title('Curva de aprendizado')

17 legend('Train', 'Cross Validation')

18 xlabel('Número de exemplos (intervalo corresponde a 100 exemplos)')

19 ylabel('Erro')


3.2 Testes e Resultados

Durante todo o projeto, uma série de alterações e tentativas foi realizada,

tanto nos códigos quanto nos dados, a fim de melhorar a sua precisão. Essas

65

tentativas envolveram a alteração da arquitetura da rede, alteração da quantidade de

atributos utilizados (dimensões das imagens), utilização de diferentes valores para o

parâmetro de regularização e a aquisição de mais exemplos para o conjunto de

treinamento. Toda vez que um treinamento era realizado com alguma modificação

nos parâmetros do algoritmo, a qualidade do aprendizado adquirido com essas

novas configurações era mensurada e registrada em um arquivo .txt para análise.

O que foi possível constatar com os testes realizados, em relação ao

número de unidades na camada de entrada, foi que os melhores valores variavam

entre 576 e 1024, ou seja, quando as imagens foram redimensionadas para tamanhos

entre 24x24 e 32x32, obtiveram-se resultados mais positivos. Acredita-se que com

imagens menores, as informações perdidas foram relevantes para uma menor

qualidade do aprendizado, e imagens maiores que 32x32 dificultava o trabalho da

RNA em encontrar os melhores parâmetros para generalização de novos exemplos.

O número de unidades na camada intermediária também foi definido

através de testes com diferentes valores. Conforme visto no capítulo 2, não existe

nenhuma resposta geral para a escolha da quantidade de nós nessa camada e isso

depende do contexto e complexidade do problema. Por isso foram realizados testes

com valores entre 15 e 120, e dessa forma se pôde concluir que as arquiteturas que

resultaram nas melhores qualidades de aprendizado, na sua maioria, continham

apenas 25 unidades na camada intermediária. De alguma forma, essa quantidade

pareceu ideal para mapear a relação entre os padrões de entrada e a classe de saída.

Em relação ao parâmetro de regularização 𝜆 , quando configurado com

valor maior que 1.24, esse fator comprometia o desempenho da rede. Portanto,

evidenciou-se que valores mais próximos a zero proporcionavam um maior

equilíbrio entre a rigidez e a variância da rede.

Um dos fatores que constantemente contribuiu para uma melhora na

precisão medida através da classificação novos exemplos foi o aumento da

quantidade de dados utilizados para treinamento. Como exemplo, é possível

comparar um teste realizado no início de setembro, em que a rede foi treinada com

5.431 exemplos, com outro teste parecido, executado no fim de novembro, onde

66

foram utilizados 8.699 dados para treinamento. Com o aumento do número de

exemplos de treinamento, a precisão de generalização aumentou em quase 5%.

Figura 23 Exemplo de curva de aprendizado gerado no Octave


A Figura 23 demonstra uma curva de aprendizado, gerada durante um dos

testes realizados, que possibilitou identificar um problema de alta variância

(overfitting) em relação ao modelo criado. Analisando esse gráfico, percebe-se que

o aumento do número de exemplos utilizados no treinamento reduziu o erro

calculado pela função de custo no conjunto de validação13

, e isso estimulou a

aquisição de mais dados para treinamento. Contudo, depois de 8.000 imagens

coletadas, o impacto na qualidade do aprendizado deixou de ser relevante.

Os melhores resultados obtidos durante os testes realizados são

apresentados na Tabela 3. Nessa tabela, é possível analisar que, mesmo modificando

algumas configurações, tanto nos dados quanto na implementação da RNA, não foi

possível obter nenhum modelo com precisão maior que 90%.

13

Nesse caso foi utilizado o conjunto de teste como conjunto de validação.

67

Tabela 3 Dez melhores resultados obtidos.

Qtde. de dados

treinados

Qtde. de dados

avaliados

Nº de unidades na cama-

da 1

Nº de unidades na cama-

da 2

𝜆 Iterações Custo final

Precisão Data do

treinamento

7652 618 1024 25 0,16 100 0,14145 88,35 25/09/2014

7652 618 625 25 0,01 100 0,13341 87,38 24/09/2014

7410 823 676 25 0,16 100 0,1481 87,36 19/10/2014

7751 627 484 25 1 100 0,22904 87,24 19/09/2014

7751 627 625 40 0.64 100 0,23657 87,08 18/09/2014

7652 618 625 25 0,01 100 0,30163 86,73 23/09/2014

7652 618 1024 35 1.24 100 0,14985 86,57 26/09/2014

7652 618 625 25 0,24 100 0,18198 86,41 24/09/2014

7410 823 676 25 0,16 100 0,19163 86,27 19/10/2014

7652 618 1024 25 0.08 100 0,13307 85,92 25/09/2014


3.3 Conclusão

O resultado que representou a melhor generalização nos exemplos do

conjunto de teste, contendo 618 imagens, foi realizado em 25 de Setembro e

alcançou 88,35% de precisão. Observando os exemplos que não foram avaliados

corretamente e as hipóteses calculadas para eles, foi possível identificar que o

modelo falhava, de maneira considerável, na classificação de algumas fotos. Foi

visto, por exemplo, que algumas fotos que atendem perfeitamente os critérios de

uma boa foto para o perfil do LinkedIn, foram definidas como ruins (valores de

ℎ𝜃(𝑥) bem próximo a zero).

Com a finalidade de melhorar esse resultado, foram realizadas tentativas

com diferentes arquiteturas e configurações, além de também tentar variar a

quantidade de épocas, porém nada elevou consideravelmente a precisão da rede

neural. A medida que demonstrou melhor impacto nos resultados foi o aumento de

dados no conjunto de treinamento, e por esse motivo o conjunto de validação criado

foi anexado ao conjunto de treinamento.

Um dos aspectos que provavelmente impossibilitaram a RNA de obter

resultados melhores foi a rigorosidade na coleta dos dados. Algumas imagens,

68

apesar de corresponderem a fotos de rosto e bem posicionadas, foram atribuídas à

pasta de fotos inválidas por conterem elementos inadequados como óculos escuros,

máscaras, pinturas no rosto, celulares (fotos do tipo “selfie”), entre outros. Esses

pequenos detalhes, que foram determinantes para que essas fotos fossem definidas

como inválidas, podem ter confundido a rede no seu processo de generalização.

Considerando o parágrafo anterior, a rede desenvolvida assim como o pré-

processamento dos dados realizado, devido à complexidade dos dados, foram

insuficientes para alcançar uma solução ótima para o problema. Por esse motivo, no

próximo capítulo são elencados possíveis trabalhos futuros que pretendem

modificar o modelo criado a fim de aumentar a precisão na tarefa de classificação

desempenhada pelo protótipo desenvolvido.

69

4 CONSIDERAÇÕES FINAIS

Neste trabalho, foram abordados os fundamentos do funcionamento de

redes neurais artificiais e apresentado um protótipo de software utilizando uma rede

MLP com uma única camada oculta, treinada para classificar se determinada foto é

apropriada para utilização no perfil da rede social profissional LinkedIn. O

algoritmo de treinamento utilizado foi o backpropagation.

O protótipo foi desenvolvido sobre o GNU Octave versão 3.2.4, que se

mostrou uma ótima ferramenta para implementação de redes neurais artificiais. Um

algoritmo inicial pode ser rapidamente desenvolvido e o conceito de vetorização

inserido no ambiente do programa possibilita códigos simples e rápidos.

A grande dificuldade encontrada durante o projeto foi a definição da

arquitetura de rede a ser trabalhada e a criação do conjunto de dados utilizado. A

atividade de seleção manual dos dados e a separação deles entre as duas diferentes

classes existentes demandou bastante tempo.

Para avaliar a precisão do protótipo desenvolvido foram realizados

diferentes testes e experimentos em um conjunto contendo fotos boas e ruins,

conforme as características levantadas durante o trabalho. Os padrões foram obtidos

através dos algoritmos estabelecidos no item 3.2.3.

Segundo os dados apresentados no item 3.3, foi possível verificar que a

RNA desenvolvida, apesar da grande complexidade dos dados, foi capaz de

generalizar novos exemplos. Entretanto atingiu um índice de precisão equivalente a

88%, o que evidencia uma possível falha nos dados e/ou na RNA desenvolvida.

Em virtude do que foi mencionado anteriormente, o presente trabalho

oferece oportunidades de trabalhos futuros com o objetivo de aumentar a qualidade

70

do treinamento e consequentemente melhorar a precisão na etapa de generalização.

Logo, destacam-se os seguintes pontos de grande interesse:

Avaliar novos procedimentos para o pré-processamento dos dados,

extraindo as informações mais relevantes para o aprendizado e

diminuindo a complexidade nas variáveis de entrada da RNA;

Aumentar relativamente o conjunto de dados a fim de possibilitar o

uso de algoritmos de seleção de modelo, e assim determinar de

forma eficiente quais as melhores configurações para a rede.

Classificar a foto em diferentes cenários e utilizar classificação de

múltiplas classes ao invés de classificação binária no projeto da

rede MLP.

Estudar o comportamento de outros tipos de redes neurais, como

por exemplo, redes neurais convolucionais e verificar sua

aplicabilidade para problemas similares ao levantado neste

trabalho.

Utilizar outras técnicas de aprendizado supervisionado, como por

exemplo, máquinas de vetores de suporte.

De maneira geral, pode-se concluir que o objetivo estabelecido neste

trabalho, de desenvolver um protótipo de software que fosse capaz de aprender a

classificar imagens a partir dos dados coletados, de acordo com as características

correspondentes a qualidade da foto requerida para uso no perfil do LinkedIn, foi

atingido.

REFERÊNCIAS BIBLIOGRÁFICAS

ABERDEEN GROUP (Org.). What Is Your Most Effective Source of Hire? 2013.

Disponível em: <http://web.jobvite.com/rs/jobvite/images/Aberdeen Sourcing Re-

port.pdf>. Acesso em: 27 ago. 2014

ALPAYDIN, Ethem. Introduction to Machine Learning. [s.l]: The Mit Press,

2010. 584 p.

BISHOP, Christopher M.. Pattern Recognition and Machine Learning. New

York: Springer, 2006.

BRAGA, Antônio de Pádua; CARVALHO, André Carlos Ponce de Leon Ferreira

de; LUDERMIR, Teresa Bernarda. Redes neurais artificiais: teoria e aplicações. 2.

ed. Rio de Janeiro: Livros Técnicos e Científicos, 2011. xii, 226 p.

BULLHORN (Org.). AN INSIDE LOOK AT SOCIAL RECRUITING IN THE

USA: THE BULLHORN REACH RANKINGS REPORT. 2012. Disponível em:

<http://reach.bullhornreach.com/reach/cmsites/default/files/BullhornReachRankings

Report Final_0.pdf>. Acesso em: 27 ago. 2014.

CALDEIRA, André. Seu perfil no LinkedIn: qual a 1a impressão? 2014. Dispo-

nível em: <http://exame.abril.com.br/rede-de-blogs/muito-trabalho-pouco-

stress/2014/02/02/seu-perfil-no-linkedin-qual-a-1a-impressao/>. Acesso em: 27 ago.

2014.

CONCEIÇÃO, Daniel Tré da. Redes Neurais Artificiais Aplicadas ao Jogo da

Velha 3D em Pinos. 2009. 84 f. TCC (Graduação) - Curso de Tecnólogo da Infor-

mação e da Comunicação, Instituto Superior de Tecnologia em Ciência da Informa-

ção de Petrópolis, Petrópolis, 2009. Disponível em:

<http://www.lncc.br/~borges/doc/Redes Neurais Artificiais Aplicadas ao Jogo da

Velha 3D em Pinos.TCC.pdf>. Acesso em: 20 set. 2014.

DOYLE, Alison. How to Take and Choose a Good Profile Photo for Linkedin.

2014. Disponível em: <http://jobsearch.about.com/od/tips/qt/linked-profile-

photo.htm>. Acesso em: 27 ago. 2014.

EATON, John W.. About GNU Octave. 2013. Disponível em:

<https://www.gnu.org/software/octave/about.html>. Acesso em: 20 out. 2014.

EATON, John W.. GNU Octave. 2013. Disponível em:

<https://www.gnu.org/software/octave/>. Acesso em: 20 out. 2014.

HEMPEL, Jessi. How LinkedIn will fire up your career. 2010. Disponível em:

<http://money.cnn.com/2010/03/24/technology/linkedin_social_networking.fortune/

>. Acesso em: 27 ago. 2014.

JOBVITE (Org.). Social Recruiting Survey Results 2013. 2013. Disponível em:

<http://web.jobvite.com/rs/jobvite/images/Jobvite_2013_SocialRecruitingSurveyRe

sults.pdf>. Acesso em: 27 ago. 2014.

KLINE, Scott R.. A Professional Photographer’s Guide to Getting the Right

LinkedIn Profile Photo. 2014. Disponível em:

<http://blog.linkedin.com/2014/07/14/a-professional-photographers-guide-to-

getting-the-right-linkedin-profile-photo/>. Acesso em: 05 dez. 2014.

LAKATOS, Eva Maria; MARCONI, Marina de Andrade. Técnicas de pesquisa:

planejamento e execução de pesquisas, amostragens e técnicas de pesquisa, elabora-

ção, análise e interpretação de dados . 7. ed. São Paulo: Atlas, 2008. 277 p. ISBN

9788522451524.

LINKEDIN (Brasil) (Org.). LinkedIn - Tendências globais em recrutamento pa-

ra 2013: As cinco principais tendências em atração de talentos que você precisa

saber. 2013. Disponível em: <http://pt.slideshare.net/linkedin-talent-

solutions/global-recruiting-trends-2013-brazil-portuguese>. Acesso em: 27 ago.

2014.

LUGER, George F.. Artificial Intelligence: Structures and Strategies for Complex

Problem Solving. Massachusetts: Pearson Education, 2009. 754 p.

IDOETA, Paula Adamo. Redes sociais mudam a dinâmica da busca por empre-

gos. 2013. Disponível em:

<http://www.bbc.co.uk/portuguese/noticias/2013/08/130808_redes_sociais_empreg

os_pai.shtml>. Acesso em: 27 ago. 2014

MAHONEY, Carol; LERMUSI, Yves. How to Measure and Improve Quality of

Hire: Results from a roundtable with Silicon Valley companies. 2010. Disponível

em: <http://web.checkster.com/wp-content/uploads/2012/09/Checkster-Quality-of-

Hire-Roundtable.pdf>. Acesso em: 04 dez. 2014.

MARSLAND, Stephen. Machine Learning: An Algorithmic Perspective. [s.l]:

Chapman & Hall/CRC, 2009.

MITCHELL, Tom. Machine Learning. [s.l]: McGraw-Hill, 1997. 414 p.

NASH, Adam. A Photo is Worth a Thousand Words. 2007. Disponível em:

<http://blog.linkedin.com/2007/09/27/a-pictures-wort/>. Acesso em: 27 ago. 2014.

NG, Andrew. Advice for applying machine learning: Learning curves. Disponível

em: <https://class.coursera.org/ml-005/lecture/39>. Acesso em: 30 out. 2014.

NG, Andrew. Introduction: What is Machine Learning. Disponível em:

<https://class.coursera.org/ml-005/lecture/2>. Acesso em: 09 set. 2014.

NG, Andrew. Linear Regression with one variable: Gradient descent. Disponível

em: <https://class.coursera.org/ml-005/lecture/11>. Acesso em: 06 out. 2014

NG, Andrew. Linear Regression with multiple variables: Gradient descent in

practice I: Feature Scaling. Disponível em: <https://class.coursera.org/ml-

005/lecture/21>. Acesso em: 28 out. 2014.

NG, Andrew. Logistic Regression: Cost function. Disponível em:

<https://class.coursera.org/ml-005/lecture/58>. Acesso em: 07 out. 2014.

NG, Andrew. Logistic Regression: Hypothesis Representation. Disponível em:

<https://class.coursera.org/ml-005/lecture/34>. Acesso em: 25 set. 2014.

NG, Andrew. Neural Networks: Learning: Backpropagation Algorithm. Disponí-

vel em: <https://class.coursera.org/ml-005/lecture/51>. Acesso em: 27 out. 2014.

NG, Andrew. Neural Networks: Learning: Implementation note: Unrolling pa-

rameters. Disponível em: <https://class.coursera.org/ml-005/lecture/53>. Acesso

em: 30 out. 2014.

NG, Andrew. Neural Networks: Learning: Random initialization. Disponível em:


NG, Andrew. Neural Networks: Representation: Examples and Intuitions I. Dis-

ponível em: <https://class.coursera.org/ml-005/lecture/47>. Acesso em: 17 set.

2014.

NG, Andrew. Neural Networks: Representation: Model Representation I. Dispo-

nível em: <https://class.coursera.org/ml-005/lecture/58>. Acesso em: 20 out. 2014.

NG, Andrew. Neural Networks: Representation: Non-linear Hypotheses. Dispo-

nível em: <https://class.coursera.org/ml-005/lecture/43>. Acesso em: 10 set. 2014.

NG, Andrew. Octave Tutorial: Basic operations. Disponível em:


NG, Andrew. Octave Tutorial: Vectorization. Disponível em:


NG, Andrew. Regularization: The problem of overfitting. Disponível em:


NIELSEN, Michael A.. Neural Networks and Deep Learning. 2014. Disponível

em: <http://neuralnetworksanddeeplearning.com/chap1.html>. Acesso em: 06 nov.

2014.

PARENZA, Greice Kelly et al. Analisando o Papel das Redes Socias no Processo

de Recrutamento e Seleção: Um Estudo Multicaso em Empresas do Setor Metal

Mecânico. 2013. Disponível em:

<http://semead6.tempsite.ws/16semead/resultado/trabalhosPDF/1038.pdf>. Acesso

em: 10 ago. 2014

RIBEIRO, Thyago. Multiplicação de Matrizes. Disponível em:

<http://www.infoescola.com/matematica/operacoes-com-matrizes-multiplicacao/>.

Acesso em: 29 out. 2014

RUSSELL, Stuart; NORVIG, Peter. Artificial Intelligence: A Modern Approach. 3.

ed. New Jersey: Pearson Education, 2010. 1132 p.

RUSSELL, Stuart; NORVIG, Peter. Inteligência artificial: tradução da segunda

edição. Campinas: Campus, 2004. 1021 p.

SEETHA, M. et al. ARTIFICIAL NEURAL NETWORKS AND OTHER ME-

THODS OF IMAGE CLASSIFICATION. Journal Of Theoretical And Applied

Information Technology. [S.l], p. 1039-1053. nov 2008. Disponível em:

<http://www.jatit.org/volumes/research-papers/Vol4No11/5Vol4No11.pdf>. Acesso

em: 19 ago. 2014

SKEELS, Meredith M.; GRUDIN, Jonathan. When Social Networks Cross

Boundaries: A Case Study of Workplace Use of Facebook and LinkedIn. 2009.

Disponível em: <http://research.microsoft.com/en-

us/um/people/jgrudin/publications/newwave/socialnetworking2009.pdf>. Acesso

em: 27 ago. 2014.

THAI, Le Hoang; HAI, Tran Son; THUY, Nguyen Thanh. Image Classification

using Support Vector Machine and Artificial Neural Network. International

Journal Of Information Technology And Computer Science. [S.l], p. 32-38.

maio 2012. Disponível em: <http://www.mecs-press.org/ijitcs/ijitcs-v4-n5/IJITCS-

V4-N5-5.pdf>. Acesso em: 19 ago.

THE LADDERS. Keeping an eye on recruiter behavior: NEW STUDY CLARIFIES

RECRUITER DECISION-MAKING. 2012. Disponível em:

<http://cdn.theladders.net/static/images/basicSite/pdfs/TheLadders-EyeTracking-

StudyC2.pdf>. Acesso em: 04 dez. 2014.

THE MATHWORKS INC (Ed.). MAT-File Format. Natick, Massachusetts (USA):

The Mathworks, Inc, 2014. 38 p. Disponível em:

<http://www.mathworks.com/help/pdf_doc/matlab/matfile_format.pdf>. Acesso em:

27 out. 2014.

http://200.135.4.10/cgi/Demetrios.exe/show_exemplares?id_acervo=39966

TCC-BrunoAzevedoCosta

Documents

Transcript of TCC-BrunoAzevedoCosta