TCC-BrunoAzevedoCosta

155 visualizações

Publicada em

0 comentários
0 gostaram
Estatísticas
Notas
  • Seja o primeiro a comentar

  • Seja a primeira pessoa a gostar disto

Sem downloads
Visualizações
Visualizações totais
155
No SlideShare
0
A partir de incorporações
0
Número de incorporações
20
Ações
Compartilhamentos
0
Downloads
3
Comentários
0
Gostaram
0
Incorporações 0
Nenhuma incorporação

Nenhuma nota no slide

TCC-BrunoAzevedoCosta

  1. 1. 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
  2. 2. 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
  3. 3. 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. IFC- Câmpus Camboriú Prof.ª Cátia dos Reis Machado, Dra. IFC - Câmpus Camboriú Prof.ª Sônia Regina Lamego Lino, Dra. IFC- Câmpus Camboriú
  4. 4. 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
  5. 5. 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
  6. 6. 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
  7. 7. 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
  8. 8. 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.
  9. 9. 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
  10. 10. 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.
  11. 11. 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).
  12. 12. 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
  13. 13. 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.
  14. 14. 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.
  15. 15. 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
  16. 16. 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.
  17. 17. 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.
  18. 18. 17 Em 1861, um estudo da afasia feito por Paul Broca com pacientes cujos cérebros foram danificados permitiu o conhecimento da existência de áreas localizadas do cérebro responsáveis por funções cognitivas específicas; mas somente em 1873 foi possível observar os neurônios do cérebro individualmente (RUSSELL; NORVIG, 2004, p.12). Por fim, a conclusão alcançada por Searle (1992 apud RUSSELL e NORVIG, 2004, p.13), foi de que uma “coleção de células simples pode levar ao pensamento, à ação e à consciência”. Figura 1 Partes de um neurônio. Fonte: Russell e Norvig (2004, p.13) Atualmente sabe-se, conforme explicitado por Marsland (2009, p.11), que o cérebro é um sistema poderoso e complexo capaz de lidar com dados distorcidos e muitas vezes inconsistentes, e produz respostas rápidas e geralmente corretas sobre esses dados. Este órgão é composto por células nervosas, unidades processadoras do cérebro, chamadas neurônios (Figura 1), e cada um deles pode ser visto como um processador separado (MARSLAND, 2009, p.11-12). As RNAs, por sua vez, baseiam-se nesse modelo para tentar “reproduzir com fidelidade várias funções cognitivas e motoras dos seres humanos” (BRAGA et al., 2014, p.6). De acordo com Russell e Norvig (2004, p.18), o primeiro trabalho desenvolvido reconhecido como IA foi realizado por Warren McCulloch e Walter Pitts, em 1943, onde ambos propuseram um modelo de neurônios artificiais caracterizados por status “ligado” ou “desligado”, ocorrendo a troca de status para
  19. 19. 18 “ligado” em resposta à estimulação por um número suficiente de neurônios vizinhos. Figura 2 Modelo do neurônio apresentado por McCulloch e Pitts. Fonte: Marsland (2009, p.14) Nesse modelo, apresentado na Figura 2, McCulloch e Pitts provaram que qualquer função computável podia ser calculada por certa rede de neurônios conectados, e que todos conectivos lógicos podiam ser implementados por estruturas de redes simples. Por fim, eles sugeriram que se definidas adequadamente, essas redes seriam capazes de aprender. Considerando outros trabalhos importantes para história e evolução das RNAs, tem-se o trabalho desenvolvido por Rosenblatt, o perceptron (BRAGA et al., 2014, p. 4). A partir desse novo modelo, Rosenblatt demonstrou que “se fossem acrescidas sinapses ajustáveis as RNAs com neurônios MCP poderiam ser treinadas para classificar certos tipos de padrões” (BRAGA et al., 2014, p. 4). Seu objetivo, conforme descrito por Braga et al. (2014, p.4), era desenvolver RNAs que fossem capazes de fazer descobertas interessantes sem a necessidade de seres humanos estabelecendo regras explícitas para isso. Segundo Braga et al. (2014, p.4-5), os estudos sobre RNAs desapareceram durante os anos de 1970, e ressurgiram na década de 1980, com a descrição do algoritmo backpropagation (algoritmo utilizado neste trabalho e detalhado no item 2.3). A partir desse momento, foi possível provar que RNAs com múltiplas camadas eram capazes de resolver problemas complexos, anteriormente impossíveis de se resolver através dos modelos com uma única camada, e desde então, pesquisas e estudos voltados para RNAs ganharam bastante atenção permanecendo forte até os
  20. 20. 19 dias atuais (BRAGA et al., 2014, p.5). As RNAs, consoante com Braga et al. (2014, p.18), são normalmente aplicadas a situações em que “existem dados, experimentais ou gerados por meio de modelos, por meio dos quais a rede adaptará os seus pesos visando à execução de uma determinada tarefa”. Braga et al. (2014, p.18) ainda descrevem que as principais tarefas em que as RNAs se aplicam são: classificação, categorização (clustering), aproximação, previsão e otimização. Devido sua importância para desenvolvimento do corrente trabalho, observa-se a seguir, de forma minuciosa, no que consistem as tarefas de classificação: Problemas de classificação envolvem a tarefa de atribuir a um padrão desconhecido uma entre várias classes conhecidas. A resolução de problemas de classificação por meio de RNAs se caracteriza basicamente por aprendizado supervisionado, em que exemplos, de padrões são apresentados às entradas e as classes correspondentes são apresentadas às saídas da rede durante o processo de aprendizado. A rede deverá, então, adaptar os seus pesos de forma a mapear as relações entre padrões de entrada e classes correspondentes de saída, tendo por base os dados do conjunto de treinamento. Assim, a classificação envolve, após o treinamento, atribuir uma das classes conhecidas a um padrão qualquer de entrada (BRAGA et al., 2014, p.18). Em conformidade com o que foi exposto por Braga et al. (2014, p.18), constata-se que a aprendizagem é uma etapa essencial para que seja possível realizar as tarefas de classificação. De forma geral, essa etapa se resume em apresentar um conjunto de exemplos para a rede, possibilitando a ela extrair as características necessárias para representar a informação recebida e para posteriormente “gerar respostas para o problema” (BRAGA et al., 2014, p.3). Essa capacidade das RNAs em aprender com dados existentes e fornecer respostas coerentes a dados ainda não conhecidos (generalização), extraindo informações implícitas, é sem dúvida, segundo Braga et al. (2014, p.3), o seu principal atrativo.
  21. 21. 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
  22. 22. 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 𝟏 𝟏+𝒆−𝒙. Fonte: Russell e Norvig (2009, p.726) Saídas (outputs): As saídas de uma rede neural são os valores encontrados
  23. 23. 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
  24. 24. 23 considerar a definição geral do que vem a ser aprendizado. Simon (1983, apud LUGER, 2009, p.388) descreve, de maneira sucinta, que aprendizado pode ser compreendido como “qualquer mudança em um sistema que o permita ter um desempenho melhor na segunda vez em que se repete a mesma tarefa”. Mesmo que breve essa descrição resume muito do que acontece no desenvolvimento de programas com capacidade de aprender (LUGER, 2009, p.388). Uma definição um pouco mais técnica, partindo para o conceito de aprendizado de máquina, é dada por Mitchell (1997, p.2) e determina que “Um computador aprende a partir de uma experiência E de acordo com alguma tarefa T e algum desempenho mensurado P, se seu desempenho em T, medido por P, melhora através da experiência E”. Contudo, é possível observar que, apesar de apresentado de forma diferente, o conceito explorado por Mitchell sobre aprendizado é similar ao abordado por Simon. Outra visão sobre aprendizado, desta vez inserida no cenário das RNAs, é apresentada a seguir: Aprendizado é o processo pelo qual os parâmetros livres de uma rede neural são ajustados por meio de uma forma continuada de estímulo pelo ambiente externo, sendo o tipo específico de aprendizado definido pela maneira particular como ocorrem os ajustes dos parâmetros livres (MENDEL; MCLAREN, 1970, apud BRAGA et al., 2014, p.12). Logo, conforme a citação de Mendel e McLaren, o tipo de aprendizado está ligado à maneira como as mudanças são feitas no sistema, ou mais tecnicamente falando, à maneira como os parâmetros desses sistemas são ajustados para melhorar a precisão em sua generalização (BRAGA et al., 2014, p.12). Uma das maneiras de se compreender o que foi descrito por Mendel e McLaren é analisar a seguinte fórmula apresentada por Braga et al. (2014, p.12): “𝑤( 𝑡 + 1) = 𝑤( 𝑡) + ∆𝑤(𝑡)”. Com essa fórmula, o autor descreve o processo de aprendizagem, onde “𝑤( 𝑡) e 𝑤( 𝑡 + 1) representam os valores dos pesos nos instantes 𝑡 e 𝑡 + 1, respectivamente, e ∆𝑤(𝑡) é o ajuste aplicado aos pesos”. Com isso, o paradigma no qual se enquadra determinado algoritmo de aprendizado é
  25. 25. 24 estabelecido pela forma como ∆𝑤( 𝑡) é calculado (BRAGA et al., 2014, p.12). Entre os principais paradigmas de aprendizado mencionados por Braga et al. (2014, p.13) está o aprendizado supervisionado. Para detalhar esse tipo de aprendizado, Russell e Norvig (2004, p.630) descrevem que “o problema da aprendizagem supervisionada envolve a aprendizagem de uma função a partir de exemplos de suas entradas e saídas”. Corroborando as ideias de Russell e Norvig sobre aprendizado supervisionado, Braga et al. (2014, p.13) consideram a necessidade da figura de um supervisor, que será responsável por observar a saída calculada pelo algoritmo e comparar o resultado com o valor de saída desejado. Levando em consideração a fórmula apresentada anteriormente, pelo mesmo autor, o aprendizado supervisionado pode ser caracterizado como os ajustes do conjunto de pesos 𝑤𝑖 de maneira a aproximar a saída calculada com a saída desejada. Logo, a cada etapa de treinamento desse tipo de sistema, é esperado minimizar essa diferença a fim de se chegar a uma possível solução (BRAGA et al., 2014, p.13). Para realizar os cálculos anteriormente abordados, o aprendizado supervisionado é composto por diversos tipos de algoritmos, que visam obter um mapeamento dos padrões de entrada e saída. Entre eles, um dos mais conhecidos, aplicado a redes de múltiplas camadas, é o algoritmo backpropagation, que será tratado a seguir (BRAGA et al., 2014, p.13). 2.3 Backpropagation 2.3.1 Motivação Em redes de uma única camada, o treinamento e o aprendizado da rede são realizados através da correção de erros, que busca “minimizar o erro da resposta atual da rede em relação à saída desejada” (BRAGA et al., 2014, p.13). De acordo com Ng (2014), a fórmula ideal para calcular esse erro, em tarefas de classificação, é representada pela seguinte função 𝐸:
  26. 26. 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).
  27. 27. 26 Figura 6 Efeito do algoritmo declínio de gradiente. Fonte: Marsland (2009, p.51) O efeito do algoritmo de declínio de gradiente em uma função não convexa é ilustrado na Figura 6. Na figura, Marsland (2009, p.51) propõe a ideia de uma bola rolando sobre uma superfície e, conforme a força da gravidade, descendo até atingir uma das cavidades dessa superfície. Neste momento, é dito que o algoritmo encontrou um local mínimo. É importante salientar que para funções convexas não existem locais mínimos. Nesse caso, existe apenas um mínimo global, e por esse motivo, ao executar o algoritmo de declínio de gradiente não há riscos de o algoritmo ficar parado em um local mínimo e não encontrar o ponto ótimo global (NG, 2014). A utilização da função 𝐽 em conjunto com o algoritmo de declínio de gradiente, indicado previamente, é satisfatória para o aprendizado em redes de uma única camada. Todavia, para redes de múltiplas camadas, apenas essas duas abordagens não são o suficiente, conforme pode ser observado a seguir: [...] Para redes de uma única camada, o erro é obtido diretamente através da diferença entre a saída desejada e a saída corrente da rede. No entanto para múltiplas camadas esse procedimento pode ser aplicado somente para a camada de saída, já que não existem saídas desejadas definidas para as camadas intermediárias. Assim, o problema passa a ser então, como calcular ou estimar o erro das camadas intermediárias (BRAGA et al., 2014, p.67). De acordo com Braga et al. (2014, p.67), é possível identificar a existência de um problema relacionado às redes de múltiplas camadas. Braga et al. (2014, p.67) destacam que o erro nas camadas ocultas (intermediárias), necessita ser estimado, entretanto, não pode ser calculado da mesma maneira como se é feito nas
  28. 28. 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 ×
  29. 29. 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.
  30. 30. 29 Figura 9 RNA utilizada como exemplo para calcular a etapa de alimentação direta da rede. Fonte: Adaptado de Ng (2014) 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 ...
  31. 31. 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 Fonte: elaborado pelo autor 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 ...
  32. 32. 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
  33. 33. 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 Fonte: elaborado pelo autor 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 𝑚 ∆𝑖𝑗 (𝑙) ;
  34. 34. 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
  35. 35. 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 Fonte: elaborado pelo autor 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.
  36. 36. 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
  37. 37. 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.
  38. 38. 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. Fonte: Marsland (2009, p.66) 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).
  39. 39. 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
  40. 40. 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)
  41. 41. 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.
  42. 42. 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
  43. 43. 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. Fonte: Adaptado de Ng (2014) 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.
  44. 44. 43 Figura 14 Segundo exemplo de curva de aprendizado. Fonte: Russell e Norvig (2009, p.703) 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).
  45. 45. 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
  46. 46. 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 Fonte: elaborado pelo autor 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.
  47. 47. 46 Quadro 5 Operadores lógicos no Octave Operador Descrição == Igualdade ~ = Diferente > Maior < Menor && “E” lógico || “OU” lógico Fonte: elaborado pelo autor 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. Fonte: elaborado pelo autor 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
  48. 48. 47 Quadro 7 Exemplo de comandos FOR, WHILE e IF no Octave Fonte: elaborado pelo autor 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. Fonte: elaborado pelo autor 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;
  49. 49. 48 Quadro 9 Exemplo de chamada de função. Fonte: elaborado pelo autor Quadro 10 Função que retorna mais de uma variável. Fonte: elaborado pelo autor 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. Fonte: elaborado pelo autor >> 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; >>
  50. 50. 49 Quadro 12 Exemplo de implementação vetorizada Fonte: elaborado pelo autor 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. Fonte: elaborado pelo autor 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
  51. 51. 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,
  52. 52. 51 treinamento da rede neural artificial, avaliação da precisão da rede na generalização de novos exemplos e classificação de fotos específicas. Figura 17 Tela inicial do protótipo Fonte: print screen do software no sistema operacional Windows 8 O processo de desenvolvimento do protótipo, a explanação do seu funcionamento e os códigos utilizados são apresentados nos parágrafos seguintes. No item 3.5 são abordados os testes e resultados obtidos com o protótipo construído. 3.1.1 Criação do conjunto de dados Para criação do conjunto de dados a ser utilizado no projeto, foi realizada uma seleção manual de fotos disponíveis na internet. Depois de baixadas, as fotos foram separadas em dois diretórios diferentes, levando em consideração os aspectos condizentes com uma foto adequada para exibição no perfil do LinkedIn, listados no item 1.3. As fotos consideradas boas foram movidas para a pasta nomeada por “Fotos válidas”, e as que representavam exemplos de fotos ruins, foram colocadas na pasta “Fotos inválidas”.
  53. 53. 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
  54. 54. 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); Fonte: elaborado pelo autor 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.
  55. 55. 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 Fonte: elaborado pelo autor 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
  56. 56. 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. Fonte: print screen do Octave no sistema operacional Windows 8 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
  57. 57. 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.
  58. 58. 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]; Fonte: elaborado pelo autor Figura 22 Comando whos executado após inicialização do algoritmo. Fonte: print screen do Octave no sistema operacional Windows 8
  59. 59. 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 Fonte: elaborado pelo autor 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.
  60. 60. 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 Fonte: elaborado pelo autor 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 Fonte: elaborado pelo autor
  61. 61. 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 Fonte: elaborado pelo autor O Quadro 20 apresenta o restante da função J adicionando o termo de
  62. 62. 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); Fonte: elaborado pelo autor 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

×