Machine Translated by Google

Estudos em Inteligência Computacional 866

Witold Pedrycz
Editores Shyi-Ming Chen

aprendizado profundo:
conceitos e
Arquiteturas
Machine Translated by Google

Estudos em Inteligência Computacional

Volume 866

Editor da série

Janusz Kacprzyk, Academia Polonesa de Ciências, Varsóvia, Polônia

Machine Translated by Google

A série “Estudos em Inteligência Computacional” (SCI) publica novidades e

avanços nas diversas áreas da inteligência computacional – de forma rápida e
com alta qualidade. A intenção é cobrir a teoria, aplicações e métodos de design
de inteligência computacional, incorporados nos campos de engenharia, ciência
da computação, física e ciências da vida, bem como as metodologias por trás
deles. A série contém monografias, notas de aula e volumes editados em
inteligência computacional abrangendo as áreas de redes neurais, sistemas
conexionistas, algoritmos genéticos, computação evolucionária, inteligência
artificial, autômatos celulares, sistemas auto-organizados, computação suave,
sistemas fuzzy e sistemas inteligentes híbridos . . De particular valor tanto para os
colaboradores quanto para os leitores são o curto prazo de publicação e a
distribuição mundial, que permitem ampla e rápida disseminação dos resultados da pesquisa.
Os livros desta série são submetidos para indexação no Web of Science, EI-
Compendex, DBLP, SCOPUS, Google Scholar e Springerlink.

Mais informações sobre esta série em [Link]

Machine Translated by Google

Witold Pedrycz • Shyi-Ming Chen

Editores

Deep Learning: Conceitos

e Arquiteturas

123
Machine Translated by Google

Editores
Witold Pedrycz Shyi Ming Chen
Departamento de Engenharia Departamento de Ciência da
Elétrica e de Computação Computação e Engenharia da Informação
Universidade de Alberta Universidade Nacional de Ciência e
Edmonton, AB, Canadá Tecnologia de Taiwan
Taipei, Taiwan

ISSN 1860-949X ISSN 1860-9503 (eletrônico)

Estudos em Inteligência Computacional
ISBN 978-3-030-31755-3 ISBN 978-3-030-31756-0 (eBook) [Link]
10.1007/978-3-030-31756-0

© Springer Nature Switzerland AG 2020

Este trabalho está sujeito a direitos autorais. Todos os direitos são reservados à Editora, quer se trate da
totalidade ou de parte do material, nomeadamente os direitos de tradução, reimpressão, reutilização de
ilustrações, recitação, difusão, reprodução em microfilmes ou de qualquer outra forma física, e transmissão ou
armazenamento de informação e recuperação, adaptação eletrônica, software de computador ou por
metodologia semelhante ou diferente agora conhecida ou desenvolvida no futuro.
O uso de nomes descritivos gerais, nomes registrados, marcas comerciais, marcas de serviço, etc. nesta
publicação não implica, mesmo na ausência de uma declaração específica, que tais nomes estejam isentos
das leis e regulamentos de proteção relevantes e, portanto, livres para uso geral.
A editora, os autores e os editores podem presumir com segurança que os conselhos e informações contidos
neste livro são verdadeiros e precisos na data de publicação. Nem o editor nem os autores ou os editores dão
garantia, expressa ou implícita, com relação ao material aqui contido ou por quaisquer erros ou omissões que
possam ter sido cometidos. A editora permanece neutra em relação a reivindicações jurisdicionais em mapas
publicados e afiliações institucionais.

Esta impressão da Springer é publicada pela empresa registrada Springer Nature Switzerland AG
O endereço da empresa registrada é: Gewerbestrasse 11, 6330 Cham, Suíça
Machine Translated by Google

prefácio

O aprendizado profundo oferece uma abordagem interessante e conceitual e algorítmica

de última geração para Inteligência Artificial e Sistemas Inteligentes, em geral. Esse
paradigma tem sido aplicado a várias áreas, incluindo tradução automática, visão
computacional e processamento de linguagem natural. O aprendizado profundo,
considerado um subconjunto do aprendizado de máquina, usa um nível hierárquico de
redes neurais artificiais para realizar com eficiência o processo de aprendizado de máquina.
Este volume fornece ao leitor um tratado abrangente e atualizado na área de
aprendizagem profunda. Existem dois aspectos focais e intimamente associados aqui,
ou seja, conceitos suportados pelo ambiente de aprendizado profundo e uma infinidade
de suas arquiteturas. Essas duas faculdades estão fortemente entrelaçadas e vinculadas
ao domínio de aplicação em discussão. Os conceitos de deep learning giram em torno
dos mecanismos estruturais e automáticos (em grau significativo) de representação do
conhecimento. Uma variedade de arquiteturas multicamadas traz as peças de
conhecimento tangíveis e funcionalmente significativas. O seu desenvolvimento
estrutural torna-se essencial para soluções práticas de sucesso. Os desenvolvimentos
arquitetônicos que surgem aqui apoiam seu aprendizado e refinamentos detalhados.
Os capítulos, de autoria de pesquisadores ativos na área, trazem uma coleção de
estudos que refletem sobre as tendências atuais em design e análise de topologias de
aprendizado profundo e áreas aplicadas de realizações bem-sucedidas, incluindo
modelagem de linguagem, representação gráfica e previsão.
Gostaríamos de aproveitar esta oportunidade e expressar nossos agradecimentos
ao Editor-Chefe da Série, Professor Janusz Kacprzyk, que desempenhou um papel
fundamental na realização do volume, fornecendo constante incentivo e apoio. Estamos
em dívida com a equipe entusiasmada da Springer; esses são os profissionais que,
como sempre, deram conselhos e orientações, além de tornarem toda a produção
eficiente e concluída em tempo hábil.

Edmonton, Canadá Witold Pedrycz

Taipei, Taiwan Shyi Ming Chen

v
Machine Translated by Google

contente

Arquiteturas de Deep Learning .................................. 1

Mohammad-Parsa Hosseini, Senbao Lu, Kavin Kamaraj,
Alexander Slowikowski e Haygreev C. Venkatesh
1 Fundo ............................................. 2
2 Procedimento de Treinamento .......................................... 2
2.1 Aprendizado Supervisionado .................................. 2
2.2 Aprendizado Não Supervisionado .............................. 3
2.3 Aprendizagem Semi-supervisionada .............................. 3
3 Categorias de Aprendizado Profundo .................................. 4
3.1 Redes Neurais Convolucionais (CNNs) ................... 4
3.2 Redes não supervisionadas pré-treinadas......... 10
3.3 Redes Neurais Recorrentes e Recursivas ................ 13
4 Conclusões .......................................... 22
Referências ............................................. 23

Caracterização Teórica de Redes Neurais Profundas .............. 25

Piyush Kaul e Brejesh Lall
1 Visão geral .............................................. 25
2 Arquitetura de Rede Neural .................................. 26
3 Breve Histórico Matemático ....................... 31
3.1 Topologia e Coletores .............................. 31
3.2 Geometria e Curvatura Riemanniana ....................... 33
3.3 Processamento de Sinais em Gráficos ....................... 37
4 Caracterização por Complexidade Homológica ................... 40
4.1 Números Betty ............................................. 40
...........
4.2 Seleção de Arquitetura da Homologia do Conjunto de Dados 42
4.3 Homologia Computacional .............................. 42
4.4 Medições Empíricas .............................. 43

viii
Machine Translated by Google

viii contente

5 Caracterização por Transformada de Espalhamento ....................... 45 5.1

Visão Geral ................. ......................... 45 5.2 Invariantes e
Simetrias ....................... . ...... 46 5.3 Translação e
Difeomorfismos ........................ 47 5.4 Contração e Separação de Escala
por Ondas ..... .. ....... 48 5.5 Banco de Filtros, Remoção de Fase e
Contrações ........ 48 5.6 Grupos de Tradução .......... .. .................. 49 5.7
Espalhamento Inverso e Esparsidade ........................ .. .. 51 6 Caracterização
por Curvatura .............................. 51 6.1 Teoria do Campo Médio e Curvatura
Gaussiana .. ... ............ 51 6.2 Medição de Curvatura Riemanniana e
Ricci ............... 56 Referências ........... ... ....................................... 61

Análise de dimensionamento de arquiteturas de processamento

tensor especializado para modelos de aprendizado profundo ..................... 65
Yuri Gordienko, Yuriy Kochura, Vlad Taran, Nikita Gordienko, Alexandr Rokovyi,
Oleg Alienin e Sergii Stirenko 1 Introdução ............................................. ........
66 2 Antecedentes e Trabalhos Relacionados .............................. 67 2.1 Núcleos
Tensor .. ......................................... 68 2.2 Unidades de Processamento
Tensor ... . ......................... 69 2.3 Outros Aceleradores de
DNNs .................. ............. 69 2.4 Algoritmos Paralelos e Arquiteturas de
Processamento Tensor ....... 70Computacional2.5 Algoritmos Paralelos
em DNNs.......e Complexidade
71 3 Detalhes
Experimentais e Computacionais ....................... 73 3.1 Conjuntos de dados,
equipamentos, métricas e modelos ................. 73 3.2 Complexidade de
computação de DNNs ....................... 77 3.3 escala Análise...............
de . .........................
78 4 Resultados ....................... .... ................... Vgg16
.... 79 4.1
....................................
79 4.2 ResNet50 ............................................. 85 4.3
CapsNet . ......................................... 85 5 Discussão .... .........................................
91 6 Conclusões ...... ......................................... 95
Referências.... ......................................................... 96

Avaliação de Arquiteturas de Autoencoder para Representação de Dados ....

101 Karishma Pawar e Vahida Z. Attar 1 Introdução .................................... ...............
102 2 Arquitetura Geral e Taxonomia de Autoencoders .......... 103 3 Variantes
de Autoencoders ......... ......................... 104

3.1 Codificadores Automáticos Específicos de Aplicação .........................

106 3.2 Codificadores Automáticos Regularizados ......... . .......... 110 3.3
Autoencoders Robustos Tolerantes a Ruídos .......... 113 3.4 Autoencodes
Generativos ........ . ....................... 114
Machine Translated by Google

contente ix

4 Fatores que Afetam o Desempenho Geral dos Autoencoders ........... 117

4.1 Treinamento ....................................... 117
4.2 Função Objetivo .............................. 118
4.3 Funções de Ativação......................... 120
4.4 Tamanho e Profundidade da Camada .............................. 120
5 Aplicações de Autoencoders .......................... 120
6 Conclusão ............................................. 126
Apêndice ................................... 126
Referências ....................................... 128

O Encoder-Decoder Framework e Suas Aplicações......... 133

Ahmad Asadi e Reza Safabakhsh
1 Introdução ............................................. 133
1.1 Tradução Automática .............................. 134
1.2 Legenda de Imagem/Vídeo .......................... 135
1.3 Resposta de perguntas textuais/visuais ....................... 135
1.4 Sumarização de Texto .............................. 136
2 Modelo de Codificador-Decodificador de Linha de Base .......................... 136
2.1 Antecedentes ....................................... 136
2.2 O Modelo Codificador-Decodificador para Tradução Automática ......... 137
2.3 Formulação ....................................... 137
2.4 Codificadores em Tradução Automática (Extração de Recurso) ........... 139
2.5 Decodificadores em Tradução Automática (Modelagem de Linguagem) ...... 140
3 Variedades de Estrutura de Codificador .................................. 141
3.1 Sentença como Entrada .............................. 142
3.2 Imagem como Entrada ....................................... 143
3.3 Vídeo como Entrada ....................................... 144
4 Variedades de Estrutura do Descodificador ....................... 151
4.1 Dependências de Longo Prazo .............................. 151
4.2 LSTMs ............................................. 152
4.3 RNNs empilhados ............................................. 152
4.4 Desaparecimento de gradientes em decodificadores empilhados ................... 154
4.5 Aprendizado por Reforço .......................... 156
5 Mecanismo de Atenção .............................. 160
5.1 Mecanismo Básico ................................... 160
5.2 Extensões .......................................... 161
6 Trabalho Futuro ............................................. 163
7 Conclusão ............................................. 163
Referências ............................................. 164

Aprendizado Profundo para Aprendizagem de Representações em Gráfico .................. 169

Wenwu Zhu, Xin Wang e Peng Cui
1 Introdução ............................................. 169
Machine Translated by Google

x contente

2 Incorporação de rede preservando a proximidade de alta ordem ............ 171

2.1 Definição do Problema .................................... 172
2.2 O Modelo SDNE 2.3 ................................... 173
Análise e Discussões sobre SDNE .......... 178
3 Estrutura Global Preservando a Incorporação de Rede ............... 179
3.1 Preliminares e Definições .............................. 180
3.2 O Modelo DRNE ................................... 181
4 Estrutura preservando a incorporação de hiper-rede ............... 185
4.1 Notações e Definições ..........................
187
4.2 O Modelo DHNE ................................... 188
5 Incorporação de rede com reconhecimento de incerteza ....................... 192
5.1 Notações ......................................... 193
5.2 O Modelo DVNE ................................... 194
6 Incorporação de Rede com Reconhecimento Dinâmico ....................... 197
6.1 O Modelo DepthLGP ........................ 199
6.2 Extensões e Variantes .......................... 205
7 Conclusão e Trabalho Futuro .......................... 206
Referências ....................................... 207

Redes neurais profundas para rótulos corrompidos......... 211

Ishan Jindal, Matthew Nokleby, Daniel Pressel, Xuewen Chen
e Harpreet Singh
1 Introdução ............................................. 212
2 Ruído de Etiqueta ............................................. 214
3 Relação com o Trabalho Anterior .................................. 215
4 Abordagem Proposta ....................................... 217
4.1 Abordagem Proposta ................................... 218
.......................
4.2 Justificando o Modelo de Ruído Não Linear 221
5 Resultados Experimentais ................................... 223
5.1 Configuração Geral ....................................... 223
5.2 Ruído de Etiqueta Artificial .................................. 224
5.3 Ruído de Rótulo Real .............................. 228
5.4 Efeito do Tamanho do Lote ................................... 230
5.5 Compreendendo o Modelo de Ruído .................. 231
6 Conclusão e Trabalho Futuro .............................. 233
Referências................................................. 233

Construindo uma rede neural convolucional com um

Capacidade para uma Tarefa de Segmentação Semântica ....................... 237
Yalong Jiang e Zheru Chi
1 Introdução ............................................. 238
2 técnicas para explorar totalmente o potencial da baixa capacidade
Redes .................................................... 244
2.1 Metodologia .......................................................... 244
Machine Translated by Google

contente XI

3 Estimativa da Complexidade da Tarefa .......................... 251

3.1 Metodologia .......................................... 251
3.2 Resumo ......................................... 256
4 Otimização da Capacidade do Modelo ...................... 256
4.1 Metodologia ....................................... 256
4.2 Resumo ......................................... 264
5 Conclusão e Trabalho Futuro .......................... 265
Referências................................................. 265

Usando redes neurais convolucionais para prever eventos esportivos

Resultado .................................................. . 269 _
Mu-Yen Chen, Ting-Hsuan Chen e Shu-Hong Lin
1 Introdução ............................................. 270
2Revisão da Literatura ....................................... 271
2.1 Arquitetura de Rede Neural Convolucional .... 271
..............
2.2 Pesquisa Relacionada Sobre Previsões Esportivas 272
3 Métodos de Pesquisa .............................. 273
3.1 Ambiente de Desenvolvimento .................... 273
3.2 Processo de Pesquisa .................................... 273
3.3 Projeto do Experimento ......................................... 277
3.4 Avaliação de Desempenho .......................... 279
4 Resultados do Experimento .............................. 279
4.1 Descrição do Conjunto de Dados .................................. 279
4.2 Resultados dos Experimentos 1 e 2 ....................... 280
4.3 Resultados do Experimento 3 ....................... 281
4.4 Resultados do Experimento 4 .......................... 282
4.5 Discussão ................................................... 283
5 Conclusões ............................................. 284
Referências................................................. 285

Sistema de Computação Heterogêneo para Aprendizado Profundo ........... 287

Mihaela Maliÿa, George Vlÿduÿ Popescu e Gheorghe M. ÿtefan
1 Introdução ............................................. 287
2 Os Componentes Computacionais de um DNN Envolvido em Deep
Aprendizagem .................................... 288
2.1 Camadas Totalmente Conectadas ................... 289
2.2 Camada de Convolução .............................. 290
2.3 Camada de Agrupamento......................... 292
2.4 Camada Softmax .............................. 293
2.5 Juntando Tudo .............................. 294
3 O Estado da Arte .......................... 294
3.1 MIC da Intel ............................................. 295
3.2 GPU da Nvidia como GPGPU .............................. 296
3.3 TPUs do Google.............................. 299
3.4 Concluindo sobre o estado da arte ....................... 300
Machine Translated by Google

xiii contente

4 Acelerador Map-Scan/Reduce .............................. 302 4.1 O Sistema Heterogêneo ....... . .........................

302 4.2 A Estrutura do Acelerador ....................... . ..... 303 4.3 A Micro-arquitetura .......................
304 4.4 Parâmetros de Hardware do MSRA . ......................... 308 4.5 Biblioteca
NeuralKernel ................... .. ......... 309 5 Implementação e Avaliação ....................... 310 5.1 NN
Totalmente Conectado ...... ......................... 311 5.2 Camada Convolucional ........ .......... ......... 312
5.3 Camada de Pool ........................ .......... ......... 315 5.4 Camada Softmax ....................... 316 6
Conclusões . ......................... 317 Referências......... ....................................... 318

Progresso na Modelagem de Linguagem Estatística Baseada em Rede Neural .... 321 Anup Shrikant
Kunte e Vahida Z. Attar 1 Introdução ....................... ..... ......................... 322 2 Modelagem de
Linguagem Estatística ........................ ..... ... 323 2.1 Modelo de linguagem N-Gram ..............................
324 .... ..... .............. 325 3 Extensões para o Modelo de Linguagem N-Gram 4 Modelagem de
Linguagem Baseada em Rede Neural ...............
(NNLM)......328
328
4.14.2
Modelo
Modelos
de Linguagem
de Linguagem
de Rede
de Rede
Neural
Neural
Modelos de Linguagem de Memória de Longo Curto Prazo Recorrente
(LSTMLM) (RNNLM)....
...... 331 4.4 RNN 330 4.3
Bidirecional .............................. 332 5 Marcos na Pesquisa NNLM .............................. 334 6 Métricas
de Avaliação .......... . ......................... 336 6.1 PPL de última geração .............. . ................... 337
7 Conclusão ................... . ......... 338 Referências .............................. . ........... ...... 338

Índice .................................................... ..... 341

Machine Translated by Google

Arquiteturas de aprendizado profundo

Mohammad-Parsa Hosseini, Senbao Lu, Kavin Kamaraj, Alexander

Slowikowski e Haygreev C. Venkatesh

Resumo O aprendizado profundo é uma das técnicas de aprendizado de máquina mais utilizadas e
que alcançou enorme sucesso em aplicações como detecção de anomalias, detecção de imagens,
reconhecimento de padrões e processamento de linguagem natural. As arquiteturas de aprendizado
profundo revolucionaram o cenário analítico de big data em meio à implantação em larga escala de
redes sensoriais e protocolos de comunicação aprimorados. Neste capítulo, discutiremos várias
arquiteturas de aprendizado profundo e explicaremos seus conceitos matemáticos subjacentes. Uma
visão geral atualizada aqui apresentada diz respeito a três categorias principais de redes neurais, a
saber, Redes Neurais Convolucionais, Redes Não Supervisionadas Pré-treinadas e Redes Neurais
Recorrentes/Recursivas. As aplicações de cada uma dessas arquiteturas em áreas selecionadas,
como reconhecimento de padrões e detecção de imagens, também são discutidas.

Palavras -chave Aprendizado profundo · Arquiteturas · CNN · Redes não supervisionadas ·

Redes recorrentes · Redes recursivas · LSTM · Autoencoders · GAN ·
Atenção DBN_ _

M.-P. Hosseini (B) · S. Lu · K. Kamaraj · A. Slowikowski · HC Venkatesh Santa Clara

University, Silicon Valley, CA, EUA e-mail: mhosseini@[Link]; parsa@[Link];
mh973@[Link]

S. Lu
e-mail: slu1@[Link]

K. Kamaraj
e-mail: kkamaraj@[Link]

A. Slowikowski
e-mail: aslowikowski@[Link]

HC Venkatesh e-
mail: hchincholivenkatesh@[Link]

M.-P. Hosseini
AI Research, San Jose, CA, EUA

Em colaboração com o Departamento de Engenharia Elétrica e de Computação,

Rutgers University, New Brunswick, NJ, EUA

Departamento de Radiologia, Henry Ford Health System, Detroit, MI, EUA

© Springer Nature Switzerland AG 2020 W. 1

Pedrycz e S.-M. Chen (eds.), Deep Learning: Concepts and
Architectures, Studies in Computational Intelligence 866, https://
[Link]/10.1007/978-3-030-31756-0_1
Machine Translated by Google

dois M.-P. Hosseini et ai.

1. Fundo
O aprendizado de máquina é um ramo da inteligência artificial (IA) que envolve algoritmos que permitem
que sistemas de computador infiram padrões de dados. O aprendizado de máquina tem um amplo escopo
de aplicações, incluindo bioinformática, detecção de fraudes, análise de mercado financeiro, reconhecimento
de imagem e processamento de linguagem natural (NLP).
As técnicas tradicionais de aprendizado de máquina estatística são limitadas em sua capacidade de
processar dados naturais em forma bruta porque os padrões e as inferências que devem ser feitas entre
eles são complicados. Eles exigem muito trabalho dos humanos para extrair recursos adequados para
melhorar seu desempenho. O aprendizado de representação é então desenvolvido como um conjunto de
métodos que permite que uma máquina descubra automaticamente as representações (recursos)
necessárias para detecção ou classificação de dados.
O aprendizado profundo é uma classe de métodos de aprendizado de máquina de representação com
vários níveis de representação. Ele é composto por vários módulos simples, mas não lineares, que
transformam a representação dos níveis anteriores (começando com a entrada bruta) em uma representação
em um nível mais alto e um pouco mais abstrato. Com a composição de transformações suficientes,
características e inferências muito complexas podem ser aprendidas. Em geral, todos os métodos de
aprendizado profundo podem ser classificados em uma das três categorias diferentes, que são Redes
Neurais Convolucionais (CNNs), Redes Não Supervisionadas Pré-treinadas (PUNs) e Redes Neurais
Recorrentes/Recursivas (RNNs). Vamos discuti-los em detalhes nas seções a seguir, mas primeiro,
discutiremos como treinar um modelo de aprendizado profundo.

2 Procedimento de Treinamento

Tanto no aprendizado profundo quanto no aprendizado de máquina, os modelos preditivos usam vários
algoritmos subjacentes para inferir relações matemáticas dos dados de treinamento. Existem basicamente
três tipos de métodos de aprendizado, a saber: aprendizado supervisionado, aprendizado não supervisionado
e aprendizado semi-supervisionado. Na seção abaixo, discutiremos cada método em mais detalhes.

2.1 Aprendizado Supervisionado

No aprendizado supervisionado, o modelo é alimentado com um conjunto de dados de treinamento

contendo tanto as observações (ou seja, entradas) quanto seus resultados correspondentes (ou seja, saídas) [11].
O modelo então infere o mapeamento matemático de entradas para saídas que pode ser usado para
classificar futuros pontos de dados de teste de entrada [7, 13]. Backpropagation, abreviação de
retropropagação de erros, é uma técnica popular de aprendizado supervisionado usada em muitas
arquiteturas de redes neurais artificiais. Na retropropagação, os pesos dos nós constituintes da rede neural
são reconfigurados de forma adaptativa para melhorar a previsão
precisão.
Machine Translated by Google

Arquiteturas de aprendizado profundo 3

2.2 Aprendizado não supervisionado

No aprendizado não supervisionado, o modelo é alimentado com dados de treinamento não classificados (ou seja, apenas
entradas). Em seguida, o modelo categoriza os pontos de dados de teste em diferentes classes, encontrando
semelhanças entre eles. Por exemplo, vamos supor que temos um animal
cenário de classificação em que o conjunto de dados contém imagens não classificadas de uma variedade
dos animais. O modelo classificará o conjunto de dados e extrairá diferentes recursos
das imagens para auxiliar na classificação. Alguns dos recursos extraídos
poderia incluir a cor do animal e o tamanho do animal para citar alguns. Usando
essas características, os dados podem ser agrupados em diferentes clusters. Por exemplo, imagens
contendo um cachorro cairá idealmente no mesmo cluster com base na aparência do
recursos extraídos; a mesma ideia se aplica aos outros animais encontrados no conjunto de dados.

2.3 Aprendizagem semi-supervisionada

Como o próprio nome sugere, o aprendizado semi-supervisionado herda propriedades do aprendizado

supervisionado e do aprendizado não supervisionado. Um conjunto de dados semi-supervisionado contém
principalmente pontos de dados de treinamento não classificados juntamente com pequenas quantidades de dados classificados.
Os modelos semi-supervisionados apresentam duas vantagens importantes. Primeiro, eles são substancialmente
mais precisos do que os modelos não supervisionados com a adição de alguns
Os pontos de dados. Dois, eles são significativamente menos trabalhosos e demorados em comparação
ao aprendizado supervisionado. A aprendizagem semi-supervisionada pode referir-se tanto a
aprendizagem ou aprendizagem indutiva.
O objetivo do aprendizado transdutivo é inferir os rótulos corretos para os dados não rotulados fornecidos. O
autotreinamento é um método transdutivo comumente usado para treinamento semissupervisionado.
Aprendendo. Neste método, um classificador é treinado primeiro com a amostra de dados rotulados.
Em seguida, o classificador é usado para classificar o conjunto de dados não rotulado. Normalmente o mais seguro
dados não rotulados, juntamente com seus rótulos previstos, são anexados ao conjunto de treinamento.
O classificador é treinado novamente com os novos dados e o processo é repetido. Esse processo de
retreinamento do classificador por si só é chamado de autoaprendizagem ou bootstrapping. a
O modelo está então pronto para classificar os pontos de dados de teste. Por outro lado, indutivo
O aprendizado é usado para deduzir o mapeamento entre entrada e saída. Os modelos generativos indutivos são
possivelmente o método de aprendizagem semi-supervisionado mais antigo. Ele assume uma
modelo, p(x, y) = p(y)p(x|y) onde p(x|y) é uma distribuição de mistura reconhecível.
Com grandes quantidades de dados não rotulados, os componentes da mistura podem ser reconhecidos;
então, idealmente, exigimos apenas um exemplo rotulado por componente para determinar completamente
a distribuição da mistura.
Machine Translated by Google

4 M.-P. Hosseini et ai.

Fig. 1 Uma representação condensada de Redes Neurais Convolucionais (CNN). É um tipo de rede neural
artificial feed forward baseada em arranjos neuronais 3D, conectividade local entre neurônios de camadas
adjacentes e vetores de peso compartilhados.

3 categorias de aprendizado profundo

Nesta seção abaixo, discutiremos várias arquiteturas de aprendizado profundo e explicaremos seus
algoritmos subjacentes. Uma visão geral atualizada será apresentada para cada uma das três
principais categorias de redes neurais, a saber, Redes Neurais Convolucionais, Redes Não
Supervisionadas Pré-treinadas e Redes Neurais Recorrentes/Recursivas.

3.1 Redes Neurais Convolucionais (CNNs)

As CNNs são inspiradas em processos biológicos e são projetadas para imitar a conectividade neural
encontrada no córtex visual do cérebro. Eles exigem consideravelmente menos pré-processamento
de dados em comparação com algoritmos tradicionais de classificação de imagens que exigem filtros
de pré-processamento projetados à mão [6]. As CNNs têm uma grande variedade de aplicações em
reconhecimento de imagem e vídeo, sistemas de recomendação, classificação de imagens, análise
de imagens médicas e processamento de linguagem natural (NLP).

3.1.1 Estrutura CNN

As CNNs diferem das redes neurais convencionais, pois realizam convolução em vez da multiplicação
de matriz padrão em pelo menos uma de suas camadas (Fig. 1). Eles são famosos por dois atributos
distintos: interações esparsas e compartilhamento de parâmetros. Interações esparsas ou
conectividade são alcançadas tornando o kernel do modelo menor que o tamanho da entrada. Por
exemplo, em um aplicativo de classificação de imagem, pode haver milhões de pixels representando
uma imagem de alta resolução. Nesse caso, o kernel será configurado de forma a capturar apenas
características importantes, como contraste e bordas, que são mais indicativas dos objetos na
imagem. Com menos pixels da imagem em consideração, há uma redução nos parâmetros para
Machine Translated by Google

Arquiteturas de aprendizado profundo 5

Fig. 2 Uma rede à esquerda sem

esparso e uma rede à direita usando X(1) X(1)
e 1) e 1)
esparso com um kernel de 3

X(2) e (2) X(2) e (2)

X(3) e (3) X(3) e (3)

X(4) e (4) X(4) e (4)

X(5) e (5) X(5) e (5)

X(6) e (6) X(6) e (6)

representar a imagem. Isso resulta na redução da utilização de memória, bem como na

sobrecarga computacional. Por outro lado, as redes neurais tradicionais são menos eficientes
e geram parâmetros para a interação entre cada unidade de entrada e unidade de saída [14].
O compartilhamento de parâmetros, também conhecido como pesos vinculados, envolve
vincular o valor do peso de uma unidade de entrada ao peso de outra unidade de entrada. No
caso do cenário de classificação de imagem, o compartilhamento de parâmetros garantiria que
houvesse apenas um conjunto de parâmetros aprendidos para cada local da imagem. Isso
difere das redes neurais tradicionais nas quais os pesos não são vinculados e conjuntos
separados de parâmetros são aprendidos em cada local.
Cada camada de uma rede convolucional geralmente executa três etapas. Na primeira
etapa, a camada realiza paralelamente várias convoluções para gerar um conjunto de ativações
lineares. Depois disso, a segunda etapa - geralmente chamada de estágio detector - envolve a
execução das ativações lineares por meio de funções de ativação não lineares. O objetivo disso
é, em última análise, inferir um mapeamento não linear para a saída, conforme necessário. O
estágio detector é seguido por um terceiro estágio composto por uma função de agrupamento
que faz outras alterações na saída da camada. O objetivo de uma função de agrupamento é
modificar a saída de um determinado local na rede com base nos valores estatísticos de saídas
próximas [9, 10, 18]. Isso enfatiza o aspecto convolucional das CNNs em que os valores de
vizinhança têm impacto em qualquer nó. No caso de max pooling, a operação modificará um
valor de saída de acordo com o valor máximo de sua região de vizinhança retangular. Outras
funções de agrupamento populares consideram o valor médio da região de vizinhança (Fig. 2).

Diferentes pesos são aplicados a diferentes camadas até que a rede seja capaz de filtrar os
dados e obter um resultado. Isso funciona tendo o pool de camada convolucional principal
Machine Translated by Google

6 M.-P. Hosseini et ai.

e construção de mapas de recursos baseados em diferentes filtros, ou kernels. Cada uma dessas
camadas está totalmente conectada e, finalmente, obtém uma saída. As CNNs são usadas
principalmente para classificação visual, mas podem ter muitas aplicações úteis na detecção de
texto e linguagem, rastreamento de objetos, reconhecimento de ações e outras classificações. A
equação 1 abaixo ilustra a propagação direta implementada em uma CNN, onde ÿ é o filtro nxn
e ÿ é a matriz de peso de não linearidade, Eq. 2 representa o componente gradiente para cada
peso, e a Eq. 3 representa os pesos da camada convolucional [6].

nÿ1 nÿ1
xl =ÿ a=0 b=0 ÿab ilÿ1 (i+a)(j+b) (1)
ij

ÿE ÿE ÿyl ÿE
= eu j
=
ÿxlij ÿil eu j
ÿxlij ÿil eu j
ÿ ÿxl ij(ÿ(xl i j)) (dois)

nÿ1 nÿ1 ÿE b=0 ÿxl

(iÿa)(jÿb)
ÿab = J a=0 ÿxl (iÿa)(jÿb) (3)
ÿilÿ1 eu j

ÿ1
nÿ1 nÿ1 ÿE b=0
J= a=0 ÿxl (iÿa)(jÿb) (4)

3.1.2 Arquiteturas e Aplicativos da CNN

Desde o desenvolvimento inicial da CNN, várias arquiteturas CNN foram criadas.

Alguns exemplos notáveis incluem: LeNet-5, AlexNet, ResNet e GoogLeNet. Cada uma dessas
redes ainda emprega a mesma estrutura de camadas convolucionais e extração de recursos,
mas pode variar no número de camadas que possuem, mapeamento de recursos e eficiência.

LeNet [19] é a primeira aplicação bem sucedida de redes convolucionais e foi desenvolvida
por Yann LeCun na década de 1990. Das CNNs, a mais conhecida é a arquitetura LeNet que
era usada para ler CEPs, dígitos, etc. O último trabalho é chamado LeNet-5 que é uma CNN de
5 camadas que atinge 99,2% de precisão no reconhecimento de caracteres isolados [20].

O primeiro trabalho que popularizou as redes convolucionais em visão computacional foi o

AlexNet, desenvolvido por Alex Krizhevsky, Ilya Sutskever e Geoff Hinton para a Universidade
de Toronto [18]. A principal diferença é que o AlexNet possui várias camadas convolucionais
seguidas por uma camada POOL. Ele contém oito camadas principais, onde as cinco primeiras
camadas são camadas convolucionais e as três últimas camadas são camadas totalmente
conectadas. Seguindo as camadas convolucionais, existem camadas de pool máximo adicionais
que usam a função de ativação da Unidade Linear Retificada (ReLU) não saturante em vez da
tangente hiperbólica ou das funções de ativação sigmóide. O uso do ReLU aumenta a velocidade
do AlexNet por um fator de seis, mantendo uma precisão semelhante.
Rede Neural Residual (ResNet) foi proposta em [4] pela Microsoft Research.
As camadas são reformuladas enquanto aprendem funções residuais em vez de funções não
referenciadas. Como resultado, essas redes residuais são mais fáceis de otimizar e ganham
uma precisão considerável com o aumento da profundidade da rede.
GoogLeNet é uma rede convolucional projetada por Szegedy et al. do Google [29]. É uma
CNN muito mais profunda em comparação com a AlexNet; GoogLeNet contém 22 camadas
Machine Translated by Google

Arquiteturas de aprendizado profundo 7

em comparação com as 8 camadas do AlexNet. A principal contribuição do GoogLeNet é o

desenvolvimento de uma camada inicial que reduz o número de parâmetros na rede.
Além disso, o GoogLeNet usa o método de pooling médio no topo das camadas
convolucionais, o que elimina ainda mais os parâmetros que contribuem com ganhos mínimos
de desempenho. Vale a pena notar que o GoogLeNet contém 4 milhões de parâmetros em
comparação com os 60 milhões de parâmetros do AlexNet. Existem várias versões de
acompanhamento do GoogLeNet, sendo a mais recente a Inception-v4.
Embora as CNNs sejam versáteis em vários espaços de problemas, elas ainda têm
limitações em suas arquiteturas. CNNs são conhecidas por serem propensas a overfitting e
ficarem presas em mínimos locais. Ambos os problemas levam a um menor desempenho do
modelo e maior tempo computacional. Portanto, algoritmos de otimização podem ser levados
em consideração para ajudar a compensar as limitações das CNNs. Uma abordagem de
otimização estendida para CNN é proposta por Hosseini et al. [6] com base na análise de
componentes principais (PCA), análise de componentes independentes (ICA) e algoritmo de
busca diferencial (DSA). O método proposto pode melhorar a eficiência da CNN e otimizar
sua extração de recursos, principalmente ao lidar com um conjunto de dados complexo em grande escala.

3.1.3 Propagação para frente e para trás

Quando os dados são inseridos em uma rede neural, eles inicialmente avançam pela rede
através de uma série de camadas no que é conhecido como propagação direta. A rede pode
ter vários números de camadas dentro da rede que representam a profundidade da rede e
também inclui um vetor de entrada, x. Cada camada, l, também tem uma largura que
representa o número de nós. Dentro de cada camada, aplicamos a matriz de pesos à função
de ativação; os dados de entrada, a, são multiplicados por um peso, w, e um desvio, b, é
adicionado ao resultado. Na Eq. 5, j é o nó de saída e representa o j -ésimo nó da lª camada,
e k representa o k- ésimo nó da camada anterior, l ÿ 1, que serve como nó de entrada [1]. O
valor wl jk , então, é a relação de peso que existe entre Quando
os dois nós de ambas
a matriz as camadas.
de pesos e o viés são
configurados pela primeira vez, eles são inicializados aleatoriamente por meio de um processo
conhecido como inicialização de parâmetros, sendo a0 a camada que contém o vetor de
dados de entrada (Fig. 3).

zlj = wl jkalÿ1 k + bl j (5)

k

A entrada ponderada para o jth node na lth layer, zl function,j , é então alimentado em uma ativação
f.
alj (6)
= f (zlj )

O papel de uma função de ativação é produzir uma saída, ou um mapeamento de um número

real de entrada para um número real dentro de um intervalo específico para determinar se a
informação dentro do nó é útil ou não, ou seja, para ativar o nó ou não. É a função de ativação
que cria o design em camadas para a rede neural;
Machine Translated by Google

8 M.-P. Hosseini et ai.

X(1)

ativação
Função
Calcular Perda

X(2)

Camada de entrada Camadas ocultas Camada de saída

Fig. 3 Uma Rede Neural usando Back Propagation

uma função de ativação atua como uma camada de rede neural executando operações em
os dados de entrada originais e alimentando-os para a próxima camada de rede neural
(função de ativação). Os valores produzidos pela função de ativação dependem do
tipo de função de ativação que é usada. Nem sempre há uma escolha clara ou melhor
decidir qual função de ativação usar ao projetar a rede; Este processo
requer alguma tentativa e erro para determinar qual função de ativação produzirá
os melhores resultados. Algumas das funções de ativação mais comuns estão listadas
abaixo de.

A função sigmóide, que também é conhecida como função logística, mapeia para reais
números com valores que variam entre 0 e 1.

1
f (x) = ÿ(x) = 1 + (7)
eÿx

A tangente hiperbólica, tanh, função de ativação mapeia para números reais com
valores que variam entre -1 e 1.

(ex ÿ eÿx )
f (x) = tanh(x) = (ex (8)
+ eÿx )

A função de ativação da unidade linear retificada (ReLU) mapeia para números reais com
valores que variam de 0 a ÿ.
f (x) = {0 f xf
ououxxÿ0
<0 (9)

A função de ativação do Softmax mapeia para números reais com valores que variam de
0 a 1.
exi
fi(x ) = j
(10)
ex- j
j=1
Machine Translated by Google

Arquiteturas de aprendizado profundo 9

Os valores de parâmetros inicializados que foram definidos arbitrariamente são ajustados

posteriormente à medida que a rede é treinada. Diz-se que os dados são alimentados na rede
e seu resultado final produz um vetor de saída, yˆ. A perda é então calculada usando o vetor
de saída (veja a Eq. 12).
A equação de propagação direta pode ser reduzida à simples equação vetorizada

Al = f (Wl Alÿ1 + bl ) (onze)

A retropropagação é um método de treinamento de uma rede minimizando a perda

calculada pela função de custo. A função de custo representa a distância da rede de fazer
previsões precisas com base na entrada. Existem muitos tipos diferentes de funções de custo
que podem ser usados, um dos quais é o erro quadrático médio (12) [1].

n
1
C=
dois

(yi ÿ ˆyi) (12)

n
i=1

Algoritmo 1: Propagação para frente e para trás na CNN

T
Entrada: dados M-dimensionais, x = [x1, , xN ]
begin for l := 1 ÿ#HiddenLayer s do

for i := 1 ÿ#RowunitinLayerl do
for j := 1 ÿ#ColumnunitinLayerl do = ÿ(xl
Encontre as ativações de camada por, yl + blj)
eu j eu j

Calcular o fim das entradas da próxima

camada

fim
fim
Mantenha a saída final
como yl Calcular erro na camada
de saída. begin for l :=#HiddenLayer
s ÿ 1 do
ÿE = ÿE ÿyl eu j = ÿE ÿ
Encontre a derivação parcial do erro por (ÿ(xl i j))
ÿyl eu j ÿxl ij ÿyl eu j ÿxl ij
ÿxl ij Encontre o erro na camada anterior.
fim
N-n N-n ÿxl N-n N-n
Calcule o gradiente do erro por ÿÿab = ÿE ij ÿxl = ÿE
ilÿ1
ÿÿab ij ÿxl (i+a)(j+b)
i=0 i=0 i=0 i=0 ij
FIM

onde n é o número de pontos de dados. O erro quadrático médio pode ser entendido como a
média do quadrado da diferença entre a saída desejada ou esperada e a saída real que foi
obtida pela rede [17].
A fim de otimizar a função de custo minimizando a perda, o algoritmo de otimização de
gradiente descendente é usado e os erros são retropropagados pela cadeia em direção à
frente da rede. A descida do gradiente ajusta cada peso tomando o negativo
Machine Translated by Google

10 M.-P. Hosseini et ai.

da taxa de aprendizagem multiplicada pela derivada parcial da função de custo em relação aos
pesos [1].

ÿCw = ÿÿ ÿw (13)

Com a retropropagação, podemos calcular os gradientes de uma só vez atualizando os

pesos usando a regra da cadeia [1]. Usando a regra da cadeia, os pesos para cada nó são
ajustados de acordo, multiplicando os gradientes entre si. A retropropagação tem o benefício
adicional de reduzir bastante o número de cálculos necessários para calcular os gradientes em
comparação com a propagação direta. Se a propagação direta é usada para atualizar os pesos,
ela sofre do problema de que, para cada peso, a função de custo deve primeiro ser calculada
antes de calcular a derivada parcial da função de custo em relação ao peso, resultando em uma
operação lenta e intensiva exigindo o número de parâmetros, ao quadrado, iterações através da
rede para calcular os gradientes [26]. A rede precisa completar uma iteração direta inteira para
calcular o gradiente para cada nó individual. Com a retropropagação, uma única propagação
direta é realizada para calcular a perda e, em seguida, uma única retropropagação para atualizar
os pesos em relação à perda é tudo o que é necessário para atualizar a rede.

A retropropagação também pode ser entendida a partir do pseudocódigo do Algoritmo 1.

3.2 Redes não supervisionadas pré-treinadas

A geração de dados e a extração de recursos são aplicações muito importantes no aprendizado

profundo, pois geralmente temos dados de treinamento limitados. Existem diferentes técnicas
usadas para aumentar o conjunto de dados inicial para fornecer um conjunto de dados maior
para treinar a rede. Usando algumas das arquiteturas de aprendizado profundo mais avançadas,
como Generative Adversarial Networks (GANs) e Autoencoders, podemos gerar dados sintéticos
com base no conjunto de dados original para melhorar o aprendizado do modelo. Ambas as
arquiteturas pertencem a uma família chamada Rede Não Supervisionada Pré-treinada (PUN).
PUN é um modelo de aprendizado profundo que usa aprendizado não supervisionado para
treinar cada uma das camadas ocultas em uma rede neural para obter um ajuste mais preciso
do conjunto de dados. Um algoritmo de aprendizado não supervisionado é usado para treinar
cada camada, uma de cada vez, de forma independente, enquanto usa a camada previamente
treinada como entrada. Após o pré-treinamento em cada camada, uma etapa de ajuste fino é
realizada em toda a rede usando aprendizado supervisionado. Tipos de PUNs incluem
Autoencoders, Deep Belief Networks (DBN) e Generative Adversarial Networks (GAN) [25].

3.2.1 Autoencoders

Autoencoders usam aprendizado não supervisionado para aprender uma representação para
redução de dimensionalidade onde a entrada é a mesma que a saída (Fig. 4). As três partes de
um autoencoder incluem a entrada, a saída e a camada oculta. Os dados são compactados
Machine Translated by Google

Arquiteturas de aprendizado profundo onze

Fig. 4 Uma representação de um autoencoder. Ele usa aprendizado não supervisionado para aprender uma representação para
redução de dimensionalidade onde a entrada é a mesma que a saída

em uma representação menor na camada oculta e descompactada para formar uma saída
semelhante à entrada. Isso acontece através de duas etapas principais de codificação e decodificação
do algoritmo do autoencoder [15]. Por exemplo, o seguinte é usado para representar a função de
mapeamento entre a camada de entrada e a camada oculta [24]:

y = f(xˆ) = s(W xˆ + b) (14)

onde a entrada xˆ é mapeada para a camada oculta y, ÿ é o parâmetro de codificação e W é a matriz

ponderada. Portanto, a função de decodificação seria a seguinte:

z = g (y) = x(W y + b ) (quinze)

z seria a reconstrução da entrada x [24].

Autoencoders são uma variante de redes neurais feed-forward que possuem um
viés para calcular o erro de reconstrução da entrada original [9]. Após o treinamento, os
autoencoders são usados como uma rede neural feed-forward normal para ativações.
Essa é uma forma não supervisionada de extração de recursos porque a rede neural usa apenas a
entrada original para aprender pesos, em vez de retropropagação, que possui rótulos. Eles usam
dados não rotulados em aprendizado não supervisionado e constroem uma representação
compactada dos dados de entrada. Um autoencoder é treinado para reproduzir seus próprios dados
de entrada.
Existem diferentes tipos de autoencoders. O codificador Vanilla é uma rede de três camadas,
onde a entrada e a saída são as mesmas. Se uma camada oculta não for suficiente, obviamente
podemos estender o autoencoder para usar mais camadas ocultas, conhecidas como autoencoder
multicamadas. O autoencoder convolucional usa imagens (vetores 3D) em vez de vetores 1D planos.
A imagem de entrada é reduzida para fornecer uma representação latente de dimensões menores e
força o autoencoder a aprender uma versão compactada das imagens. O autoencoder regularizado
usa uma função de perda que incentiva o modelo a ter outras propriedades além da capacidade de
copiar sua entrada para sua saída.
Machine Translated by Google

12 M.-P. Hosseini et ai.

3.2.2 Redes Adversárias Geradoras (GANs)

Generative Adversarial Networks (GAN) foi introduzido pela primeira vez por Ian Goodfellow e
outros da Universidade de Montreal em 2014. GANs são capazes de imitar qualquer distribuição
de dados em qualquer domínio: imagens, música, fala e prosa. As GANs são um exemplo de
rede que usa aprendizado não supervisionado para treinar dois modelos em paralelo. Um
aspecto fundamental dos GANs (e modelos generativos em geral) é como eles usam uma
contagem de parâmetros significativamente menor do que o normal em relação à quantidade
de dados em que a rede é treinada. A rede é forçada a representar de forma eficiente os dados
de treinamento, tornando-a mais eficaz na geração de dados semelhantes aos dados de treinamento.
Uma rede GAN é composta por um discriminador, D, e um gerador, G, que operam em
paralelo. O objetivo do gerador é ser capaz de criar uma saída falsa que se assemelhe a uma
saída real, com o gerador treinando através de suas interações com o discriminador e não a
partir de qualquer conteúdo real [2]. O objetivo do gerador é produzir uma saída tão próxima
do real que confunda o discriminador ao conseguir diferenciar os dados falsos dos dados reais.

Há três etapas em GANs. Primeiro, o gerador recebe números aleatórios e retorna uma
imagem. Essa imagem gerada é alimentada no discriminador juntamente com um fluxo de
imagens tiradas do conjunto de dados real. Em segundo lugar, o discriminador recebe imagens
reais e falsas e retorna probabilidades; uma saída próxima de 0 sendo os dados do gerador é
falsa e uma saída próxima de 1 sendo os dados reais.
Terceiro, a rede discriminadora fornece feedback ao gerador para treiná-lo e melhorar sua
saída. A GAN tem potencial para ser utilizada em muitas aplicações e tem sido utilizada na
melhoria da resolução de imagens [22]. Outra aplicação útil usando GAN tem sido a capacidade
de criar fotos com base em uma descrição detalhada da legenda, como uma legenda
informando “um caminhão amarelo com portas brancas” usada para gerar uma imagem
correspondente [27] (Fig. 5).

Fig. 5 Uma representação de uma Rede Adversarial Generativa (GAN). Ele contém uma rede geradora e
uma rede discriminadora cujo gerador cria um conjunto de dados a partir de ruído aleatório para alimentar o
discriminador para poder diferenciar o conjunto de dados gerado de um conjunto de dados real
Machine Translated by Google

Arquiteturas de aprendizado profundo 13

3.2.3 Rede de Crença Profunda

Depois de discutir as diferentes redes de aprendizado de máquina e como elas operam, examinamos
como essas diferentes redes foram usadas juntas. As redes neurais podem ser unidas em diferentes
combinações em série umas com as outras. Para isso, é estabelecido um link entre cada rede. Isso é
chamado de Deep Belief Network (DBN). Ele é estruturado conectando várias redes neurais não
supervisionadas menores e forma uma extensa conexão em camadas. Para entender melhor o conceito,
precisamos nos aprofundar nos componentes de um DBN: Rede de Crenças e a Máquina de Boltzmann
Restrita.

Uma Rede de Crenças consiste em camadas de unidades binárias geradas aleatoriamente, onde cada
uma das camadas conectadas recebeu uma função de peso. A faixa dessas unidades binárias é de “0”
a “1”, e a probabilidade de atingir o valor “1” depende das entradas de fator de polarização e peso das
outras unidades conectadas. Devido ao aprendizado camada por camada, podemos determinar como
uma variável presente em uma camada pode interagir com essas variáveis em outro nível. Após o
processo de aprendizado, os valores das variáveis podem ser efetivamente inferidos por uma abordagem
bottom-up começando com um vetor de dados na camada inferior e adicionando a função de peso
generativo na direção oposta.

Uma Máquina de Boltzmann Restrita (RBM) é uma Rede Neural Recorrente (RNN) estocástica que
consiste em unidades binárias geradas aleatoriamente, com arestas não direcionadas entre as unidades.
Como a principal limitação do RBM é a escalabilidade, observa-se que eles têm conexões restritas entre
cada uma das unidades ocultas.

3.3 Redes Neurais Recorrentes e Recursivas

Essa classe de estruturas de aprendizado profundo tem a capacidade de enviar dados ao longo de etapas de tempo.
Apresentamos 4 estruturas nesta aula: 1. Rede Neural Recorrente, 2. Rede Neural Recursiva, 3.
Memória Longa e Curta (LSTM), 4. Atenção.

3.3.1 Rede Neural Recorrente

A Rede Neural Recorrente (RNN) é uma classe de aprendizado profundo baseada nos trabalhos de
David Rumelhart em 1986. As RNNs são reconhecidas por sua capacidade de processar e obter insights
de dados sequenciais. Portanto, análise de vídeo, legendagem de imagens, processamento de
linguagem natural (NLP) e análise de música dependem dos recursos das redes neurais recorrentes.
Ao contrário das redes neurais padrão que assumem independência entre os pontos de dados, as RNNs
capturam ativamente as dependências sequenciais e de tempo entre os dados.

Um dos atributos mais definidores sobre RNNs é o compartilhamento de parâmetros. Sem

compartilhamento de parâmetros, um modelo aloca parâmetros exclusivos para representar cada ponto de dados
Machine Translated by Google

14 M.-P. Hosseini et ai.

Nova informação

f(x)

predição

Fig. 6 Uma representação condensada da Rede Neural Recorrente (RNN). É uma rede neural que se repete ao
longo do tempo, o que permite que as informações persistam por loops. O f(x) representa alguma função de
esmagamento

em uma sequência e, portanto, não pode fazer inferências sobre sequências de comprimento variável.
O impacto dessa limitação pode ser totalmente observado no processamento de linguagem natural.
Por exemplo, as frases para decodificar são “Kobe Bryant é um jogador de basquete incrível” e “Um
jogador de basquete incrível é Kobe Bryant”. Um modelo ideal deve ser capaz de reconhecer que
'Kobe Bryant' é o jogador de basquete discutido em ambas as frases, independentemente da posição
das palavras. Uma rede multicamada tradicional nesse cenário falharia porque criaria uma interpretação
da linguagem em relação aos pesos únicos definidos para cada posição (palavra) na frase. As RNNs,
no entanto, seriam mais adequadas para a tarefa, pois compartilham pesos ao longo das etapas de
tempo (ou seja, as palavras em nossa frase) - permitindo uma compreensão mais precisa da frase [3]
(Fig. 6).

As RNNs geralmente aumentam a arquitetura de rede multicamada convencional com a adição de

ciclos que conectam nós adjacentes ou etapas de tempo. Esses ciclos constituem a memória interna
da rede que é usada para avaliar as propriedades do ponto de dados atual em relação aos pontos de
dados do passado imediato.
Também é importante notar que a maioria das redes neurais feedforward convencionais são limitadas
a mapeamento um para um para entrada e saída [3]. As RNNs, no entanto, podem realizar
mapeamentos de um para muitos, de muitos para muitos (por exemplo, tradução de fala) e
mapeamentos de muitos para um (por exemplo, identificação de voz). Um gráfico computacional é
usado para descrever os mapeamentos entre entradas para saídas e perda. Desdobrar o gráfico em
uma cadeia de eventos fornece uma imagem clara do compartilhamento de parâmetros dentro da rede.
Uma equação generalizada para relações de recorrência é
s(t) = f (stÿ1)) (16)
Machine Translated by Google

Arquiteturas de aprendizado profundo quinze

Fig. 7 Um gráfico computacional desdobrado para RNN. Cada nó está associado a uma instância de tempo

s(t) indica o estado do sistema que é dependente de um passo de tempo anterior indicado por
t ÿ 1. Esta equação pode então ser reescrita como

(t)
h(t) = f (htÿ1), x ;) (17)

(t)
onde h(t) é agora usado para representar o estado e x denota entrada de uma instância de
tempo particular. O significado de h(t) é que é uma representação dos aspectos relevantes para
a tarefa da sequência passada de entradas até t [3] (Fig. 7).
Versões anteriores das arquiteturas RNN mostraram grande promessa e versatilidade, mas
foram associadas a certas falhas notáveis. As estruturas RNN, em teoria, são capazes de
lembrar informações por longos períodos de tempo, porém, na prática, nem sempre é assim.
As redes RNN tradicionais, também conhecidas como RNNs Vanilla, são especialmente
propensas a um gradiente de fuga e um gradiente de explosão — ambos fenômenos resultantes
de erros de propagação acumulados ao longo de muitas etapas de tempo. A RNN funciona
bem na referência de bits de informação se o intervalo entre as referências permanecer
pequeno. Onde o RNN começa a sofrer é quando a lacuna entre os dados referenciados se
torna grande e o RNN nem sempre é capaz de fazer links entre esses dados. Long Short-Term
Memory (LSTM) e Truncated Backpropagation Through Time (TBPTT) são variantes da
arquitetura RNN tradicional propostas para corrigir esses problemas. A arquitetura LSTM utiliza
arestas recorrentes com pesos unitários fixos para neutralizar o gradiente de fuga.
A arquitetura TBPTT define um corte para o número de etapas através das quais o erro pode
ser propagado para corrigir o gradiente explosivo (Fig. 8).
Algumas outras arquiteturas RNN incluem redes neurais recorrentes bidirecionais
(BRNN) e Redes Neurais Recorrentes Codificador-Decodificador (EDRNN). BRNNS se desviam
das estruturas causais convencionais utilizadas pela maioria dos outros frameworks RNN. Eles
fazem inferências do ponto de dados atual em uma sequência relativa aos pontos de dados
passados e futuros. Isso é particularmente útil para decodificar o significado de frases em que
cada palavra da frase é avaliada no contexto de todos os valores da frase. Além disso, muitas
dependências sutis podem ser extrapoladas considerando os vizinhos linguísticos esquerdo e
direito de uma palavra. Também é importante notar que muitas palavras e frases usadas em
frases podem ter significados diferentes.
Machine Translated by Google

16 M.-P. Hosseini et ai.

Fig. 8 RNN bidirecional

Eu (t-1) eu (t) Eu (t+1)

F(t-1) F(t) F(t+1)

B(t-1) B(t) B(t+1)

O(t-1) O(t) OU(t+1)

L(t-1) L(t) L(t+1)

T(t-1) T(t) T(t+1)

dependendo do contexto da frase. Uma visão bidirecional permite que o

modelo tenha maior probabilidade de extrapolar corretamente esse contexto. Além da PNL, os BRNNs
também são particularmente úteis em proteômica – identificando sequências de proteínas a partir da
ordenação de aminoácidos – bem como na identificação de caligrafia.
EDRNN é outra estrutura RNN versátil que permite que o RNN seja treinado para
mapear uma sequência de entrada para sequências de saída de comprimento variável. Este quadro pode ser
muito útil para decodificar a fala, bem como para automatizar as respostas à fala.

3.3.2 Rede Neural Recursiva

Redes neurais recursivas, que não devem ser confundidas com RNNs, são um conjunto de
modelos adaptativos que são usados para processar dados de comprimento variável. Eles são
especialmente proficientes no processamento de entradas de estrutura de dados. Redes recursivas alimentam o
estado da rede de volta para si mesmo, no que pode ser visto como um loop. eles são
principalmente adequado para a desconstrução de imagens e frases. A arquitetura de redes neurais
recursivas permite que os usuários não apenas identifiquem os constituintes dos dados de entrada
mas também para determinar quantitativamente as relações entre eles [3]. esse tipo
Machine Translated by Google

Arquiteturas de aprendizado profundo 17

Fig. 9 Uma representação condensada da Rede Neural Recursiva

de desconstrução é possível através de uma matriz de peso compartilhado e árvore binária

estrutura - ambos permitem que a rede neural recursiva extrapole de
seqüências de comprimento variável de imagens e palavras. Além disso, uma grande vantagem
de redes recursivas sobre redes recorrentes é que para uma sequência de mesmo comprimento n
a profundidade (medida como o número de composições de operações não lineares) pode
ser drasticamente reduzido de n para log(n) , o que permite a captura eficiente de dependências
de longo prazo [3]. As redes neurais recursivas são geralmente conhecidas por terem
um método feed-forward de baixo para cima e um método de propagação de cima para baixo. Ambos os
mecanismos constituem a propagação através da estrutura que é predominante na maioria dos processos recursivos.
redes (Fig. 9).
Duas das variedades mais comumente usadas de redes recursivas incluem o
autoencoder recursivo semi-supervisionado e tensor neural recursivo supervisionado.
O autoencoder recursivo é usado para desconstruir sentenças para aplicações de PNL
enquanto o tensor neural recursivo é usado principalmente para aplicações de visão
computacional. Uma desvantagem comum a quase todas as redes neurais recursivas é
sobrecarga computacional - mais do que redes neurais recorrentes. Redes recursivas têm a
reputação de processar quantidades exorbitantes de dados, muitas vezes contendo mil leões de
parâmetros, o que resulta em longos tempos de treinamento. Como resultado, a otimização
técnicas são continuamente desenvolvidas para essas arquiteturas; além disso, a sofisticação
cada vez maior dos processadores e os avanços feitos na computação paralela
permitir a implantação em larga escala de redes neurais recursivas.
Machine Translated by Google

18 M.-P. Hosseini et ai.

3.3.3 LSTM

LSTM é a arquitetura RNN mais comum que lembra valores em intervalos arbitrários. Foi introduzido
pela primeira vez em 1997 por Hochreiter e Schmidhuber e funciona bem em fazer previsões com base
em dados de séries temporais, evitando o problema de dependência de longo prazo que as RNNs
tradicionais, ou vanilla, eram atormentadas. O LSTM também é adequado para tarefas de classificação
e processamento e pode ser encontrado nos aplicativos Google Translate, Apple Siri e Amazon Alexa.

Como mencionado anteriormente, o RNN sofre de um problema de contexto que é atribuível ao

fenômeno conhecido como problema do gradiente de fuga. O problema do gradiente de fuga ocorre
quando o gradiente descendente é usado como um algoritmo de otimização junto com a retropropagação
[5]. À medida que os tamanhos das lacunas aumentam entre as dependências, os gradientes de erro
desaparecem exponencialmente e podem resultar no treinamento de uma rede para se tornar muito
lenta ou até incapaz de aprender.
Com gradiente descendente estocástico, o gradiente é calculado com base na derivada parcial da
função de perda em relação aos pesos usando retropropagação usando a regra da cadeia [1]. A
descida de gradiente estocástica é uma forma otimizada de descida de gradiente. Enquanto o gradiente
descendente otimiza a perda de todas as amostras de treinamento na rede, é intensivo porque otimiza
a perda para cada amostra de treinamento; se houver um milhão de amostras de treinamento, o
gradiente será um milhão de vezes.
Usando gradiente descendente estocástico, apenas uma amostra de treinamento é usada para otimizar

Fig. 10 Um gráfico computacional expansivo para RNN

Machine Translated by Google

Arquiteturas de aprendizado profundo 19

OU
Eu(1)
v

Eu (2)
OU C v

QUALQUER

OU
Eu (3)

v C
eu

Eu(4)
OU C

Fig. 11 Cadeia RNN para estrutura de árvore binária permite que a rede neural recursiva extrapole a partir de sequências de
comprimento variável de imagens e palavras

os parâmetros da rede, reduzindo drasticamente o tempo de treinamento da rede [23]. Além

disso, outro método, a descida de gradiente de minilote, também pode ser usado para otimizar
o custo. Em vez disso, a descida de gradiente de minilote usa n número de amostras para
atualizar os parâmetros em toda a rede. Embora o gradiente descendente estocástico não
atinja a otimização máxima em comparação com o gradiente descendente, em geral, a precisão
é suficientemente próxima da otimização e é muito benéfica ao treinar uma rede com um
grande conjunto de dados [23] (Fig. 10).
As atualizações dos parâmetros na rede são aplicadas usando a regra da cadeia. Com a
regra da cadeia, os gradientes são calculados como o produto da derivada da função de custo
em relação ao peso de cada nó à medida que ele se propaga de volta na cadeia em direção à
frente da rede. O gradiente é então usado para atualizar os pesos das funções de nós
anteriores. À medida que a dependência do tempo entre as camadas aumenta, os pesos são
atualizados apenas marginalmente devido a pequenas correções calculadas para o peso [5]
(Fig. 11).
Considere o gradiente calculado com valor menor que um; com retropropagação, os pesos
são ajustados para trás e se os gradientes contiverem muitos números pequenos menores que
um, então o gradiente se torna exponencialmente pequeno quanto mais para trás a rede se
propaga; eles se tornam ainda menores quando multiplicados pelas taxas de aprendizado.
Como os pesos são inicialmente definidos para um número arbitrário ao configurar uma rede
para treinamento, eles tendem a ter inicialmente uma perda maior, agravando o problema do
gradiente de fuga, uma vez que os pesos são ajustados apenas marginalmente. O LSTM então
aborda este problema pelo uso de diferentes portas dentro de suas estruturas celulares [5].
Diferente das redes RNN clássicas, o LSTM não apenas pode derivar a informação do
estado atual, mas também pode adquirir informações de estados anteriores [11].
Os modelos LSTM são usados da seguinte forma,

ft = ÿg(W f yt + U f htÿ1 + ÿ f ) (18)

it = ÿg(Wi yt + Uihtÿ1 + ÿi) (19)

Machine Translated by Google

vinte M.-P. Hosseini et ai.

ot = ÿg(Wo yt + Uihoÿ1 + ÿo) (vinte)

ht = ot ÿ ÿh(ct) (vinte e um)

ct = ft ÿ ÿtÿ1 + it ÿ ÿc(Wc yt + Uihcÿ1 + ÿc) (22)

onde yt é o vetor de entrada, ht é o vetor de saída, ct é o vetor de estado da célula; W, U e ÿ são

matrizes e parâmetros vetoriais; e ft , it , e ot são vetores de portas de esquecimento,
portas vetores
de entrada e vetores dede
portas de saída, respectivamente [12].
Os componentes críticos do LSTM são a célula de memória e suas portas. Existem diferentes
variações de LSTM, mas todas elas incluem predominantemente três portas, conhecidas como
portão de esquecimento, portão de entrada e portão de saída. O conteúdo da célula de memória
é modulado pelas portas de entrada e portas de esquecimento. Assumindo que ambas as portas
estão fechadas, o conteúdo da célula de memória permanecerá inalterado entre um passo de
tempo e o seguinte. A estrutura de gating permite que as informações sejam retidas em muitas
etapas de tempo e, consequentemente, também permite que os gradientes fluam em muitas
etapas de tempo. Isso permite que o modelo LSTM supere o problema do gradiente de fuga que
ocorre com a maioria dos modelos de Rede Neural Recorrente. O grafo desdobrado de uma rede
LSTM pode ser pensado como uma esteira rolante, com os dados passando de uma camada para
outra, sendo levemente alterados à medida que passam por cada camada pelo uso das portas de
entrada e esquecimento usando interações lineares.
O portão de esquecimento é responsável por remover informações do estado da célula e seu
objetivo é identificar quais informações não são mais úteis e podem ser esquecidas. São
necessárias 2 entradas: o estado oculto da célula de memória anterior, h(tÿ1), e a entrada atual,
x(t), também conhecida como o estado atual da célula naquele intervalo de tempo específico. As
entradas são multiplicadas por matrizes de peso e um viés é adicionado. Depois disso, uma
função sigmóide é aplicada; a função sigmóide é responsável por decidir quais valores manter e
quais descartar. A função emite um vetor com valores de 0 a 1; um 0 indica que o portão de
esquecimento deseja esquecer a informação completamente, enquanto um 1 indica que o portão
de esquecimento deseja lembrar toda a informação.
A porta de entrada envolve um processo de 2 etapas e é responsável por decidir quais novas
informações serão adicionadas ao estado da célula. Semelhante ao portão de esquecimento, uma
função sigmóide é aplicada a h(tÿ1) e x(t). Uma função tangente hiperpolítica cria um vetor de
todos os valores possíveis, variando de -1 a 1. Esse vetor indica valores candidatos que podem
ser adicionados ao estado da célula.
A porta de saída seleciona informações úteis do estado da célula como saída em um processo
de 3 etapas. Na primeira etapa, uma função tangente hiperbólica é aplicada ao estado da célula,
criando um vetor com valores em escala de -1 a 1. A etapa 2 é usar a função sigmóide e usar o
estado oculto anterior, h(t-1), e x (t) como insumos para criar um filtro regulatório. Na etapa final,
o filtro regulador da etapa 2 é multiplicado com o vetor da etapa 1, produzindo uma saída e um
estado oculto para a próxima célula. Usando LSTM, a rede é capaz de minimizar quaisquer
dependências de longo prazo e pode preencher lacunas nas referências de dados em mais de
1.000 etapas [5] (Fig. 12).
Machine Translated by Google

Arquiteturas de aprendizado profundo vinte e um

Fig. 12 Rede de atenção

hs

atenção
Local
camada
pesos

no

Contexto
Vetor

ct ht' yt

pt
alinhado
posição

ht

3.3.4 Atenção

A maioria das arquiteturas de redes neurais contemporâneas utiliza mecanismos de recorrência e

convolução juntamente com uma configuração de codificador-decodificador. As redes de atenção
usam um mecanismo adicional de “atenção” que está crescendo em popularidade entre várias
arquiteturas. A atenção pode ser pensada de forma semelhante à forma como focamos nossa
atenção na tarefa em mãos. Por exemplo, se você for solicitado a pintar uma sala, você deve prestar
atenção na área da sala que está pintando no momento. Se você for solicitado a consertar um
veículo danificado, sua atenção estará na parte do veículo em que você está trabalhando no
momento. As redes de atenção aplicam o mesmo conceito, concentrando-se em áreas específicas
em diferentes etapas de tempo.
Usando a atenção, os modelos exibem maior precisão de previsão ao encontrar dependências
globais entre os pontos de dados sem levar em consideração sua distância nas sequências de
entrada e saída [30]. Além desse benefício, os mecanismos de atenção também tornam os cálculos
realizados pela rede neural mais paralelizáveis. Mecanismos de atenção são geralmente usados em
conjunto com recorrência e convolução; em uma pequena fração de arquiteturas de redes neurais,
a atenção pode substituir inteiramente os esquemas de recorrência e convolução. Vaswani et ai.
implementaram uma nova arquitetura desprovida de recorrência conhecida como Transformer. Essa
arquitetura faz uso de um sistema de atenção
Machine Translated by Google

22 M.-P. Hosseini et ai.

esquema de ção chamado autoatenção ou intra-atenção, no qual são extrapoladas inúmeras relações
entre diferentes posições de uma sequência de dados [30]. Assim, ao encontrar mais padrões a partir
dos dados de entrada, o mecanismo de atenção do Transformer permite a criação de modelos mais
robustos.

4. Conclusões

A incorporação de modelos de aprendizado profundo permitiu que grandes quantidades de dados

fossem correlacionadas de várias modalidades. Construídas para emular a estrutura das conexões
sinápticas no cérebro humano, as arquiteturas de aprendizado profundo são usadas de forma
onipresente para extração de recursos, análise de padrões e abstração de dados. Esses modelos
demonstraram ter um desempenho melhor e mais rápido do que as técnicas de análise atuais de
última geração por meio de tarefas de aprendizado supervisionadas, não supervisionadas e
semisupervisionadas. Este capítulo revisou várias estruturas comuns que se desenvolveram
recentemente nas três classes seguintes.
1. A rede neural convolucional, que é um poderoso método de aprendizado profundo inspirado
em processos biológicos. Ele usa pouco pré-processamento em comparação com outros algoritmos
de aprendizado de máquina, onde os algoritmos tradicionais precisam de filtros projetados à mão
para pré-processar dados. Possui uma variedade de aplicações, desde reconhecimento de imagem
até processamento de linguagem natural, com uma estrutura multicamada contendo camadas de
convolução, camadas de agrupamento e camadas totalmente conectadas.
2. As redes não supervisionadas pré-treinadas que são uma classe de algoritmos de aprendizado
profundo que geram dados e extraem recursos. As principais arquiteturas do PUN incluem
Autoencoders, Generative Adversarial Networks e Deep Belief Net. Usando essas arquiteturas,
podemos gerar dados semelhantes do conjunto de dados original para melhorar a precisão do modelo.

3. As redes neurais recorrentes/recursivas que são uma classe de estruturas de aprendizado

profundo que têm a capacidade de enviar dados em etapas de tempo. Introduzimos 4 estruturas
nesta classe, incluindo Rede Neural Recorrente, Rede Neural Recursiva, Memória Longa de Curto
Prazo e Atenção.
Há uma grande variedade de aplicações para as quais os algoritmos de aprendizado profundo
podem ser usados. Eles podem ser usados para realizar classificação, geração de dados e
compreensão de informações. Para vários campos, desde condução autônoma até bioinformática e
processamento de imagens médicas para auxiliar a área médica a fazer diagnósticos precisos [8, 16,
21]. Por exemplo, muitas arquiteturas CNN são desenvolvidas para tarefas de coleta de imagens,
incluindo AlexNet e GoogLeNet. As arquiteturas LSTM foram projetadas para processamento de
linguagem natural, uma vez que mostraram alto desempenho nesta aplicação [28]. Uma arquitetura
baseada em CNN chamada AtomNet [31] foi projetada para descoberta de medicamentos e previu
com sucesso algumas novas moléculas para o vírus Ebola Fig. 13. Pesquisas profundas e completas
foram feitas com o uso de diferentes arquiteturas de aprendizado profundo para analisar a
multimodalidade em técnicas de imagem médica [12 ].
Machine Translated by Google

Arquiteturas de aprendizado profundo 23

Fig. 13 O AtomNet é treinado para reconhecer grupos sulfonil – uma estrutura frequentemente encontrada em antibióticos [31]

As empresas de serviços financeiros desenvolveram algoritmos de aprendizado profundo para detectar

fraudes e prevenir a lavagem de dinheiro. Os aplicativos para aprendizado profundo se expandem todos os
meses para todos os cantos da academia e da indústria.

referências

1. Boden, M.: Um guia para redes neurais recorrentes e retropropagação. O Projeto Dalas
(2002)
2. Creswell A, White T, Dumoulin V, Arulkumaran K, Sengupta B, Bharath AA: Redes contraditórias generativas: uma visão
geral. Processo de Sinal IEEE. Mag. 35(1), 53–65 (2018)
3. I. Goodfellow, Y. Bengio, A. Courville: Deep Learning. Imprensa do MIT. [Link] [Link] (2016)

4. He K, Zhang X, Ren S, Sun J: Aprendizagem residual profunda para reconhecimento de imagem. In: Proceedings of the
IEEE Conference on Computer Vision and Pattern Recognition, pp. 770–778 (2016)

5. Hochreiter S, Schmidhuber J: Longa memória de curto prazo. Computação Neural. 9(8), 1735-1780
(1997)
6. Hosseini, M., Pompili, D., Elisevich, K., Soltanian-Zadeh, H.: Aprendizado profundo otimizado para big data de EEG e
previsão de convulsões BCI via internet das coisas. IEEE Trans. Big Data 3(4), 392–404 (2017)

7. Hosseini, M.-P.: Desenvolvimento de uma plataforma baseada em nuvem como serviço para melhorar a saúde pública de
pacientes epilépticos em locais urbanos. Reimagining Health in Cities: New Directions in Urban Health Research, Drexel
University School of Public Health, Filadélfia, EUA (2015)
8. Hosseini, M.-P.: Propondo um novo sistema inteligente artificial para detecção automática de crises epilépticas. J. Neurol.
Distúrbios 3(4) (2015)
9. Hosseini, M.-P.: Uma interface de computador cerebral baseada em nuvem para analisar big data médico para detecção
de crises epilépticas. In: 3º Simpósio Anual da New Jersey Big Data Alliance (NJBDA) (2016)

10. Hosseini, MP: Interface cérebro-computador para análise de big data epiléptico. Ph.D. Tese, Rutgers University-School of
Graduate Studies (2018)
Machine Translated by Google

24 M.-P. Hosseini et ai.

11. Hosseini M-P, Hajisami A, Pompili D: Detecção de crises epilépticas em tempo real a partir de sinais de EEG
através de aprendizagem aleatória de conjuntos de subespaços. In: 2016 IEEE International Conference
on Autonomic Computing (ICAC), p. 209-218. IEEE (2016)
12. Hosseini MP, Lau A, Lu S, Phoa A: Aprendizagem profunda em imagens médicas, uma revisão. IEEE Rev.
Biomed. Inglês (2019)
13. Hosseini M-P, Pompili D, Elisevich K, Soltanian-Zadeh H: Aprendizado de conjunto aleatório
para classificação do EEG. Artif. Intel. Med. 84, 146–158 (2018)
14. Hosseini MP, Soltanian-Zadeh H, Akhlaghpoor S: Método de três cortes para identificação de DPOC. Lei
Médica Iraniana 771–778 (2013)
15. Hosseini M-P, Soltanian-Zadeh H, Elisevich K, Pompili D: Aprendizado profundo baseado em nuvem de
grandes dados de EEG para previsão de crises epilépticas. In: 2016 IEEE Global Conference on Signal
and Information Processing (GlobalSIP), p. 1151-1155. IEEE (2016)
16. Hosseini M-P, Tran TX, Pompili D, Elisevich K, Soltanian-Zadeh H: Aprendizado profundo com computação
de borda para localização de epileptogenecidade usando rs-fMRI multimodal e EEG big data. In: 2017 IEEE
International Conference on Autonomic Computing (ICAC), p. 83-92.
IEEE (2017)
17. Karnin, ED: Um procedimento simples para podar redes neurais treinadas para retropropagação. IEEE
Trans. Rede Neural. 1(2), 239-242 (1990)
18. Krizhevsky, A., Sutskever, I., Hinton, GE: Classificação Imagenet com redes neurais convolucionais
profundas. In: Avanços em Sistemas de Processamento de Informação Neural, p. 1097–1105 (2012)

19. Le Cun Y, Jackel LD, Boser B, Denker JS, Graf HP, Guyon I, Henderson D, Howard RE, Hubbard W:
Reconhecimento de dígitos manuscritos: aplicações de chips de rede neural e aprendizado automático.
IEEE Comum. Mag. 27(11), 41–46 (1989)
20. LeCun, Y., Bottou, L., Bengio, Y., Haffner, P.: Aprendizagem baseada em gradiente aplicada ao documento
reconhecimento. proc. IEEE 86(11), 2278–2324 (1998)
21. LeCun Y, Bengio Y, Hinton G: Aprendizado profundo. Natureza 521 (7553), 436 (2015)
22. Ledig C, Theis L, Huszár F, Caballero J, Cunningham A, Acosta A, Aitken A, Tejani A, Totz J, Wang Z., et
al. . In: Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4681–4690
(2017)

23. Liang, N.-Y., Huang, G.-B., Saratchandran, P., Sundararajan, N.: Um algoritmo de aprendizado sequencial
on-line rápido e preciso para redes feedforward. IEEE Trans. Rede Neural. 17(6), 1411–1423 (2006)

24. Liao D, Lu H: Classifique o autismo e o controle com base no aprendizado profundo e na estrutura da
comunidade em fMRI em estado de repouso. In: 2018 Décima Conferência Internacional sobre Inteligência
Computacional Avançada (ICACI), pp. 289-294. IEEE (2018)
25. Patterson, J., Gibson, A.: Deep Learning: A Abordagem do Praticante. O'Reilly Media, Inc.
(2017)
26. Puskorius G, Feldkamp L. Retropropagação truncada ao longo do tempo e treinamento de filtro kalman para
neurocontrole. In: Proceedings of 1994 IEEE International Conference on Neural Networks (ICNN'94), vol.
4, pág. 2488-2493. IEEE (1994)
27. Reed S, Akata Z, Yan X, Logeswaran L, Schiele B, Lee H: Generative adversarial text to image síntese
(2016). arXiv pré -impressão arXiv:1605.05396 28. Sutskever I, Vinyals O, Le QV: Sequência para
sequenciar o aprendizado com redes neurais. In: Avanços em Sistemas de Processamento de Informação
Neural, p. 3104–3112 (2014)
29. C. Szegedy, W. Liu, Y. Jia, P. Sermanet, S. Reed, D. Angelov, D. Erhan, V. Vanhoucke, A. Rabinovich: Indo
mais fundo com convoluções. In: Visão Computacional e Reconhecimento de Padrões (CVPR) (2015)

30. Vaswani A, Shazeer N, Parmar N, Uszkoreit J, Jones L, Gomez AN, Kaiser ÿ, Polo sukhin I: Atenção é tudo
que você precisa. In: Avanços em Sistemas de Processamento de Informação Neural, p. 5998–6008 (2017)

31. Wallach, I., Dzamba, M., Heifets, A.: AtomNet: uma rede neural convolucional profunda para previsão de
bioatividade na descoberta de drogas baseada em estrutura (2015). arXiv pré -impressão arXiv:1510.02855
Machine Translated by Google

Caracterização Teórica de Profundo

Redes neurais

Piyush Kaul e Brejesh Lall

Resumo Redes neurais profundas são mal compreendidas matematicamente, entretanto tem
havido muitos trabalhos recentes focados em analisar e entender seu sucesso em uma variedade
de tarefas de reconhecimento de padrões. Descrevemos algumas das técnicas matemáticas
utilizadas para caracterização de redes neurais em termos de complexidade de classificação ou
tarefa de regressão atribuída, ou com base em funções aprendidas, e tentamos relacioná-las
com escolhas de arquitetura para redes neurais. Explicamos alguns dos quantificadores
mensuráveis que podem ser usados para definir a expressividade da rede neural, incluindo o
uso de complexidade e curvatura homológica. Também descrevemos as redes neurais do ponto
de vista das transformações de espalhamento e compartilhamos algumas das justificativas
matemáticas e intuitivas para elas. Finalmente compartilhamos uma técnica para visualizar e
analisar redes neurais baseada no conceito de curvatura de Riemann.

Palavras -chave Redes neurais profundas Aprendizado de máquina Expressividade Topologia

algébrica Números de Betti Curvatura Geometria Riemanniana Transformação de espalhamento

1. Visão Geral

Redes neurais profundas (DNNs), incluindo CNNs, RNNs, GANS e outras variantes são os
algoritmos de aprendizado de máquina de melhor desempenho para uma ampla gama de tarefas
variadas de reconhecimento de padrões, incluindo classificação, detecção de objetos,
segmentação semântica, reconhecimento de fala etc. 23, 36, 39, 41]. A compreensão matemática
de redes neurais de mais de uma camada oculta ainda é bastante limitada, devido à inadequação
dos modelos matemáticos em modelar efetivamente as estruturas hierárquicas complexas e não
lineares. Isso diminui a capacidade dos engenheiros de melhorar e personalizar

P. Kaul (B) B. Lall

Departamento de Engenharia Elétrica, Instituto Indiano de Tecnologia, Delhi, Índia e-mail:
eez157544@[Link]

B. Lall
e-mail: brejesh@[Link]

© Springer Nature Switzerland AG 2020 W. 25

Pedrycz e S.-M. Chen (eds.), Deep Learning: Concepts and
Architectures, Studies in Computational Intelligence 866, [Link]
10.1007/978-3-030-31756-0_2
Machine Translated by Google

26 P. Kaul e B. Lall

as redes de forma previsível. Embora o algoritmo de retropropagação e os algoritmos baseados

em gradiente descendente sejam amplamente eficazes, a otimizabilidade e a generalização de
várias arquiteturas de rede são pouco compreendidas. Assim, algumas arquiteturas falham em
convergir para uma boa solução generalizada, enquanto outras com camadas ligeiramente
diferentes convergem bem [18].
Neste capítulo, revisamos algumas áreas de pesquisa que utilizam técnicas da teoria de
processamento de sinal e topologia diferencial [6, 11, 26, 33] para desenvolver métodos e técnicas
para melhor analisar, entender e visualizar a eficácia de DNNs em várias tarefas de reconhecimento
de padrões. . Essas técnicas também podem ser estendidas para introduzir melhorias algorítmicas
e arquiteturais em arquiteturas de redes neurais, incluindo aquelas para processar dados de
entrada euclidianos e não euclidianos.
Começamos descrevendo brevemente alguns conceitos matemáticos da teoria da topologia e
da geometria riemanniana que são pré-requisitos para entender o restante deste capítulo. Também
damos uma breve visão geral do próximo campo de aprendizado profundo geométrico, que usa
processamento de sinal gráfico e outras ideias para estender o aprendizado profundo a dados não
euclidianos, como gráficos e variedades [7, 40]. Fazemos isso de forma breve e sem qualquer prova.
A seguir descrevemos o conceito de poder expressivo e os limites atualmente conhecidos nas
dimensões Vapnik–Chervonenkis [13, 21, 43] (dimensão VC) de redes neurais baseadas em
conceitos de topologia algébrica, especialmente usando números de Betti [3–5]. Também
discutimos alguns resultados teóricos e empíricos para o mesmo, que podem ter implicações
práticas no projeto de arquitetura de redes neurais [17].
Em seguida, descrevemos a abordagem de explorar redes neurais analisando modelos
simplificados usando transformadas de espalhamento [2, 9, 28, 29, 44], que consistem em camadas
de transformada wavelet intercaladas com não-linearidades e modelamos sua invariância a
distorções nos dados como difeomorfismos. utilizando a teoria de grupos de Lie e variedades
topológicas [14].
Por fim, discutimos alguns avanços muito recentes na compreensão matemática da
expressividade de redes neurais profundas utilizando geometria Riemanniana. Alguns resultados
analíticos e empíricos também são compartilhados para mostrar a variação de curvatura em
variedades Riemannianas através da propagação de dados através da rede neural. Explicamos a
pesquisa sobre modelagem de redes de aprendizado profundo por cálculo direto de tensores de
curvatura Riemanniana e Ricci e como isso pode ser usado para caracterizar, analisar e até mesmo
auxiliar no projeto de redes neurais profundas [34, 35, 37].

2 Arquitetura de Rede Neural

Embora os detalhes da arquitetura e dos componentes da rede neural sejam descritos em outro
lugar e não sejam o foco deste capítulo, fornecemos uma breve visão geral dos componentes para
poder definir a terminologia e a representação matemática dos blocos de construção básicos.
Redes neurais são estruturas computacionais com parâmetros apreensíveis que podem ser
caracterizadas como tendo múltiplas camadas computacionais com camadas conectadas entre si
por meio de grafos direcionados. Redes neurais profundas, usadas para
Machine Translated by Google

Caracterização Teórica de Redes Neurais Profundas 27

Redes neurais Ignate com mais de uma camada oculta, não são bem compreendidas matematicamente.

As Redes Neurais recebem um vetor ou tensor como entrada, que é então alimentado sequencialmente
através de uma série de camadas de processamento. As camadas são de vários tipos, dependendo do
tipo de rede e da aplicação. As camadas incluem camadas totalmente conectadas, camadas de convolução,
camadas de agrupamento, ativações não lineares, camadas de normalização, camadas de perda, etc. Os
perceptrons multicamadas (MLPs) consistem apenas em camadas totalmente conectadas intercaladas
com ativações não lineares. As Redes Neurais Convolucionais (CNNs) possuem camadas convolucionais
em vez de camadas totalmente conectadas na fase inicial da rede. Redes neurais recorrentes (RNNs) são
distinguidas de outras classes pela presença de componentes com memória, por exemplo, memória de
longo prazo (LSTMs) e unidades recorrentes fechadas (GRU) [10, 19]. Essas redes podem ser usadas
para classificação/regressão de dados orientados a séries temporais. As redes neurais modernas,
especialmente as CNNs, podem ser muito profundas com centenas de camadas.

Os perceptrons multicamadas (MLP) são a forma mais simples de redes neurais que consistem em
camadas totalmente conectadas acopladas com não-linearidades (como mostrado na Fig. 1). As camadas
totalmente conectadas podem ser modeladas como matriz para multiplicação vetorial. As não linearidades
são tipicamente operações não lineares de elemento a elemento.
As CNNs consistem em grafos acíclicos direcionados (DAG) com nós realizando uma das operações
descritas acima, por exemplo, convolução, agrupamento etc. As interconexões podem ser paralelas, seriais
ou hierárquicas (rede dentro de redes).Na sua forma mais simples, as CNNs possuem um conjunto de
camadas convolucionais alternadas com unidades lineares retificadas (ReLU) [15] camadas em série (ver
Fig. 2). As CNNs são diferenciadas das MLPs pelo compartilhamento de pesos entre as dimensões
espaciais. O propósito do compartilhamento de peso nas dimensões espaciais é fornecer invariância
espacial, que é uma característica desejada quando a entrada são imagens. Portanto, as redes neurais
convolucionais são ideais para redes de classificação e detecção de objetos que trabalham em conjuntos
de dados de imagem ou vídeo, o que requer a propriedade de invariância espacial. A dimensão espacial é
reduzida pela introdução de camadas de agrupamento, o que reduzirá o tamanho das dimensões espaciais.
O pooling também ajuda na introdução de invariância translacional e rotacional (ou covariância) na rede.
Os estágios finais em redes convolucionais também podem incluir uma ou mais camadas totalmente
conectadas que são equivalentes a camadas convolucionais com filtro de tamanho espacial 1 × 1 e entrada
de tamanho espacial 1 × 1.

RNNs são uma família de redes neurais que são usadas para processar sequências. Analogamente
às CNNs que compartilham o peso nas dimensões espaciais das imagens, as RNNs compartilham os
pesos nas dimensões temporais em sequências. O bloco de construção básico consiste em unidades
recorrentes, que possuem conexões de realimentação da saída para a entrada e mantêm o estado
(memória). Existem muitos tipos de unidades recorrentes, mas as mais comuns são unidades fechadas
como memória de longo prazo (LSTM como mostrado na Fig. 3 e RNN usando LSTM é mostrado na Fig.
4) e unidades recorrentes fechadas (GRU). Além disso, multiplicadores totalmente conectados e não-
linearidades, a capacidade de aprender, esquecer e emitir seletivamente o estado interno com base nos
coeficientes aprendidos é uma característica dessas unidades fechadas, o que lhes fornece a capacidade
de manter uma memória por períodos de tempo suficientemente longos como necessário. . Os coeficientes
das portas são aprendidos nos processos de treinamento.
Machine Translated by Google

28 P. Kaul e B. Lall

Fig. 1 Perceptrons multicamadas. a um único neurônio. b MLP com 2 camadas ocultas

Fig. 2 Exemplo de uma CNN (LeNet-5 [24])

Machine Translated by Google

Caracterização Teórica de Redes Neurais Profundas 29

Fig. 3 Unidade LSTM

Podemos modelar camadas totalmente conectadas como matriz de coeficientes para multiplicação
de vetores de entrada seguida de não linearidade pontual. Para CNNs, utilizando a expansão de
entrada do tipo im2col [30] pode ser usada para converter o mapa de características de entrada de
qualquer camada convolucional para uma matriz 2D. Portanto, podemos representar a convolução
como um produto entre uma matriz e um vetor. Seja a matriz do filtro representada como F, e ÿ seja
o operador de expansão (im2col), a saída da camada convolucional pode ser representada da
seguinte forma:
vec(y) = vec(xl+1 ) = vec(ÿ(xl )F). (1)

Para uma sucessão de camadas com convoluções alternadas e operador pontual ÿ dado por max(x,
0), podemos representar as redes como

1
vec(y) = vec(...vec(ÿ(vec(ÿ(x) )F1))F2)...FJ ). (dois)

Para gráficos acíclicos direcionados (DAG) mais complexos, a mesma expressão pode ser
estendida. As redes neurais são treinadas minimizando uma função de risco estrutural que inclui um
termo usado para medir o erro entre a previsão do
Machine Translated by Google

30 P. Kaul e B. Lall

rede neural representada por y(i) e a verdade fundamental (yˆ)(i) . Geralmente, a função de
risco estrutural de um modelo consiste em um termo de risco empírico e um termo de
regularização, que pode ser representado como

(3)
ÿÿ = arg minÿ L(ÿ) + ÿ ÿ(ÿ)

n
1 (Ei)
L y(i) , yˆ + ÿ · ÿ(ÿ) (4)
= argminÿ n
i=1

onde ÿ(ÿ) é o termo de regularização ou penalidade, e ÿ representa os parâmetros do

modelo a ser aprendido. Existem muitos tipos de funções de perda como erro quadrático
médio (MSE), entropia cruzada, divergência de Kullback-Leibler [12, 16] etc. Um exemplo
de uma função simples de perda quadrada l2 pode ser o seguinte:

L= .
dois

(y(i) ÿ ˆy(i) ) (5)

i=1

máximo suave

fc

concatenar concatenar concatenar concatenar

LSTM LSTM LSTM LSTM

LSTM LSTM LSTM LSTM

incorporação

X0 x1 x2 x3

Fig. 4 Redes neurais recorrentes

Machine Translated by Google

Caracterização Teórica de Redes Neurais Profundas 31

3 Breve Histórico Matemático

3.1 Topologia e Coletores

A topologia é um ramo da matemática que trata da caracterização de formas, espaços e conjuntos por sua
conectividade. Na topologia, expressamos a relação entre dois espaços através de mapas contínuos entre
eles.

Definição 3.1 Seja M um conjunto e P(M) o conjunto de todos os subconjuntos de M (ou seja, conjunto de
potências de M).
Um conjunto O ÿ P(M) é chamado de topologia, se todas as seguintes propriedades forem satisfeitas:

(i) Ou contém o conjunto nulo e o próprio conjunto M. (ii)

qualquer união de subconjuntos de O está contida em O, ou mais formalmente, A ÿ O, B ÿ O =ÿ A ÿ B ÿ O.
(iii) por último, qualquer interseção de número finito de subconjuntos de O está contida em Ou, ou
seja, Uÿ ÿ O.
Uÿ ÿ O, ÿ ÿ I (I é um conjunto de índices ) =ÿ ÿÿI

Os conjuntos em O são chamados de conjuntos abertos.

A noção de equivalência topológica (chamada homeomorfismo) implica que também há

ÿ1
existe uma aplicação contínua f : A ÿ B para a qual a função inversa f contínua.

Definição 3.2 Uma função f : X ÿ Y entre dois espaços topológicos (X, TX ) e (Y, TY ) é chamada de
homeomorfismo se todas as seguintes propriedades forem satisfeitas:

– f é um mapeamento um-para-um e sobre mapeamento, –

f é contínuo, – a função inversa de f também é contínua.

Uma vizinhança de um ponto x em M é um conjunto N(x) contendo um conjunto aberto que contém o
ponto x. Uma família de vizinhanças de x implica um conjunto de pontos que estão “próximos de x”. Um
espaço topológico é chamado de Hausdorff (separado) se para quaisquer dois pontos distintos sempre
existirem vizinhanças disjuntas.

Definição 3.3 Um espaço topológico de Hausdorff paracompacto (M, O) é chamado de variedade topológica
d-dimensional se ÿp ÿ M : ÿU ÿ O : p ÿ U, ÿ homeomorfismo x : U ÿ x(U) ÿ Rd satisfazendo a seguinte: (i) x é
invertível: xÿ1 : x(U) ÿ U, (ii) x é contínuo wrt (M, O) e (Rd , Ostd ), (iii) xÿ1 é contínuo.

Uma variedade topológica d-dimensional é localmente homeomorfa ao espaço euclidiano d-dimensional (Rn)
em cada ponto. Assim, em cada ponto da variedade existe um mapeamento que mapeia um conjunto aberto
na variedade para uma parte do espaço euclidiano.
Esse mapeamento é chamado de gráfico. O conjunto desses gráficos sobrepostos que cobrem toda a
variedade é chamado de atlas. Dois gráficos sobrepostos são mostrados na Fig. 5.
Machine Translated by Google

32 P. Kaul e B. Lall

Fig. 5 Coletor. As duas

regiões U e V no mapa
múltiplo para dois mapas
diferentes ÿ(x) e ÿ(x) com
alguma sobreposição

Definição 3.4 Uma curva em uma variedade M é um mapa suave (isto é, Cÿ) de algum intervalo
aberto (ÿ , ) de uma linha real em M.
Duas curvas ÿ1(0) e ÿ2(0) são tangentes em um ponto p em M se ÿ1(0) = ÿ2(0) = p e em
algum sistema de coordenadas local elas são tangentes no sentido usual de curvas em R .

Um vetor tangente p ÿ M é uma classe de equivalência de curvas em M onde a relação

de equivalência é que as duas curvas serão tangentes no ponto p. Escrevemos a classe de
equivalência de uma curva particular ÿ como [ÿ] (ver Fig. 6).

Uma função com as três propriedades definidas na Definição 3.2 é chamada de bi-contínua.
Se existe uma função bi-contínua, dizemos que X e Y são homeomorfos. Para espaços
topológicos, os homeomorfismos formam uma relação de equivalência. As classes de
equivalência resultantes são chamadas de classes de homeomorfismo. No caso de variedades
suaves, a equivalência topológica (homeomorfismo) que mantém a suavidade é chamada de
difeomorfismo.
A Topologia Algébrica atribui objetos algébricos como grupos, cadeias e objetos semelhantes
a espaços topológicos. Dois espaços podem ser considerados topologicamente equivalentes
se os objetos algébricos aos quais são atribuídos são isomórficos. No contexto de caracterização
de redes neurais, a caracterização pode ser feita pela conectividade topológica do conjunto de
dados. Em seguida, a expressividade de uma determinada rede neural é avaliada como sua
capacidade de produzir regiões de decisão com a mesma conectividade. Este aspecto é
explicado com mais detalhes na Seção 4.
Machine Translated by Google

Caracterização Teórica de Redes Neurais Profundas 33

Fig. 6 Espaço tangente Tx M de um único ponto, x, em um coletor

3.2 Geometria e Curvatura Riemanniana

Uma variedade Riemanniana é qualquer variedade suave sobre a qual um tensor simétrico de
0
Formato (
dois
) é definido. Tal tensor g é chamado de métrica. Se a métrica não for positiva
definida, então tal geometria é chamada pseudo-Riemanniana. Em cada local da
variedade, tal métrica fornece um mapeamento entre espaços vetoriais e seus duais
(uma forma). Um campo vetorial é uma função com valor vetorial que atribui um vetor a qualquer
ponto em um manifold. Para qualquer campo vetorial A(x) em um ponto x, existe um mapeamento dado
pela métrica para o campo vetorial dual:

A˜ = g(A, ·). (6)

O campo vetorial duplo A˜ pode ser pensado como agindo em B que é equivalente a um
produto escalar padrão. Ei,

g(A, B) = A˜(B) = A · B. (7)

A convenção de Einstein para somas é usada na maior parte da física matemática

literatura envolvendo relatividade e gravitação. O mesmo foi usado aqui e
será explicado agora. Nesta convenção, os índices são representados por subscritos
Machine Translated by Google

3. 4 P. Kaul e B. Lall

e sobrescritos. Subscritos indicam vetores contra-variantes e subscritos indicam

vetores covariantes, caso sejam incluídos apenas uma vez na equação. no caso de
equação tem índices repetidos como índices superior e inferior em termos separados,
aqueles podem ser contraídos, ou seja, pensados como parte de uma soma, e o sinal de soma
pode ser omitida.
As derivadas dos campos também são representadas em notação abreviada, com
vírgula antes da variável de índice indicando que a derivada é escrita nessa variável:

ÿÿ
= ÿ,ÿ . (8)
ÿÿ

Os co-vetores têm gradientes que são definidos como:

ÿÿ ÿÿ ÿÿ ÿÿ
(ÿÿ˜ ) = ( , , , ...). (9)
ÿÿ1 ÿÿ2 ÿÿ3 ÿÿ4

Cada um dos componentes do gradiente do espaço vetorial dual pode ser dado por uma matriz
transformação ÿÿ como mostrado abaixo:
ÿ

(ÿÿ˜ )ÿ¯ = ÿÿ ÿ(ÿÿ˜ )ÿ, (10)

A necessidade de derivadas covariantes e sua relação com as derivadas padrão

não é imediatamente aparente. Para entender isso, precisamos notar que os vetores de base em
caso de coordenadas curvas pode variar no espaço. Para tomar o exemplo do retângulo
e polar coordena o campo ez, que é o vetor de base unitária na direção z,
no espaço 3D euclidiano é constante ao longo do espaço. Quando convertemos isso para polar
coordenadas, este campo torna-se dependente das coordenadas e, portanto, varia
através do espaço.

ez = (ÿr z, ÿÿz ) = (cosÿ, ÿrÿ1 senÿ), (onze)

Neste caso, não obtemos derivada zero pela diferenciação de componentes de ez

wrt ÿ, embora esperássemos que a derivada fosse zero mesmo em coordenadas curvas
sistema. Portanto, a soma de derivadas de componentes individuais de um vetor não é
equivalente à derivada do próprio vetor. Para cuidar dessa inconsistência,
derivados covariantes devem ser introduzidos. Esses são definidos da seguinte forma:

ÿA _ ÿ
= (Aÿeÿ) (12)
ÿzÿ ÿzÿ
ÿAÿ _ ÿeÿ
= eÿ + Aÿ , (13)
ÿzÿ ÿzÿ

Aqui, os dois termos constituem as derivadas parciais de componentes vetoriais e a

derivada dos vetores na nova base de coordenadas, respectivamente. Isso é igual
Machine Translated by Google

Caracterização Teórica de Redes Neurais Profundas 35

ção está completa, mas por uma questão de simplicidade, definimos adicionalmente Christoffel
µ
símbolos ÿ como
ÿÿ
segue:

ÿeÿ ÿ
=ÿ (14)
ÿÿeÿ .
ÿzÿ

O símbolo de Christoffel à direita pode ser inferido como o componente ÿth de

derivada de ÿeÿ ÿxÿ . Podemos considerar ÿ o índice para a base sendo diferenciada e
ÿ a coordenada contra com a diferenciação é feita. Derivada covariante em (12)
é agora:

ÿ = Aÿ = Aÿ
(ÿA ) ÿ ;ÿ ,ÿ
+ Aÿÿ ÿ ÿÿ. (quinze)

Observe que estamos usando a notação para diferenciação indicada na Eq. 8

acima de. Os símbolos de Christoffel são calculados a partir da métrica da seguinte forma [38]

ÿ
ÿÿÿ _ = 1/2 ÿ gÿÿ(gÿÿ,ÿ + gÿÿ,ÿ ÿ gÿÿ,ÿ). (16)

Por definição, transporte paralelo de um vetor A em um caminho parametrizado pelo scaler ÿ

em qualquer variedade é quando o vetor A é definido em todos os pontos do caminho, e se o
vetores em pontos infinitesimalmente próximos podem ser considerados quase paralelos, mesmo
se os vetores em pontos mais distantes não forem.
No espaço plano euclidiano, apenas as retas paralelas transportam o vetor tangente.
Também no espaço curvo, podemos encontrar caminhos análogos às linhas retas (chamadas geodésicas)
impondo a restrição de que os vetores naqueles sejam transportados paralelamente ao longo daquele
caminho. As geodésicas são definidas como.

d dxÿ ÿ
ÿxÿ dxÿ
+ ÿÿÿ = 0. (17)
dÿ dÿ dÿ dÿ

Por definição, a curvatura Riemanniana pode ser pensada como o desvio em um vetor
quando tentamos transportá-lo em paralelo ao longo de um loop fechado no espaço de coordenadas dado.
Tal laço é mostrado na Fig. 7. Os lados do laço consistem em linhas x = a, x =
a + ÿa, y = b e y = b + ÿb.
À medida que o vetor unitário passa pelo laço composto pelos pontos P, Q, R, S e
chega de volta ao ponto original P, encontramos o desvio deste vetor no final
comparado com a posição inicial. Este desvio é dado por:

ÿ ÿ ÿ ÿ ÿ ÿ
ÿV = ÿaÿb[ÿ ÿ ÿ + ÿ ÿ2ÿ ÿ ÿ ÿ1,2 ÿ2,1 ÿ1 (18)
ÿÿ2 ]Vÿ. ÿ1ÿ

A curvatura de Riemann é derivada do cálculo acima como um tensor da forma

1
( 3 ) conforme indicado abaixo.

Rÿ = ÿ ÿ ÿÿ + ÿ ÿÿÿ ÿÿ,ÿ
ÿ
ÿÿ,ÿ
ÿ ÿ
ÿÿ ÿ ÿ
(19)
ÿÿÿ ÿÿ ÿÿÿ ÿÿ .
Machine Translated by Google

36 P. Kaul e B. Lall

Fig. 7 Loop na seção da grade de coordenadas

Também podemos calcular a curvatura Riemanniana diretamente da métrica em vez de usar

símbolos de Christoffel.

= (vinte)
Rÿÿÿÿ 1 gÿÿ(gÿÿ,ÿÿ ÿ gÿÿ,ÿÿ + gÿÿ,ÿÿ + gÿÿ,ÿÿ). dois

Para calcular o tensor de Ricci, podemos contrair a curvatura de Riemann no primeiro e terceiro
índices para dar.

Rÿÿ = Rÿ ÿÿÿ (vinte e um)

A contração do tensor de Ricci fornece ainda o scaler de Ricci.

R = gÿÿ Rÿÿ = gÿÿ gÿÿ Rÿÿÿÿ . (22)

As métricas de curvaturas podem ser consideradas curvaturas intrínsecas ou extrínsecas.

curvaturas. A curvatura extrínseca pode ser medida apenas quando o espaço múltiplo está
embutido em dimensões mais altas. Para o caso mais simples de curvas em planos, para medir a
curvatura em um ponto, primeiro encontramos o círculo osculador da Fig. 8, que é um círculo que
é a maior aproximação da curva naquele ponto. O recíproco do raio do círculo osculador é
considerado a curvatura extrínseca nesse ponto. Por outro lado, não precisamos embutir em um
espaço dimensional superior em caso de curvatura intrínseca, que pode, por definição, ser medida
de dentro do próprio espaço múltiplo. Os tensores de curvatura definidos acima são formas de
curvaturas extrínsecas, nomeadamente tensores de curvatura de Riemann e Ricci. A forma mais
básica de curvatura extrínseca é a curvatura gaussiana. Para encontrar a curvatura gaussiana em
torno de qualquer ponto p em uma variedade, precisamos encontrar a circunferência C de um
círculo de raio desenhado com o ponto como centro. Então a curvatura gaussiana pode ser
calculada como:
Machine Translated by Google

Caracterização Teórica de Redes Neurais Profundas 37

Fig. 8 Círculo osculante

6 C
kGauss = lim (1 ÿ ). (23)
ÿ0 dois
2ÿ

Ou seja, a curvatura gaussiana é uma medida de quanto a circunferência de um círculo

na variedade varia de um círculo de mesmo raio no espaço plano (2ÿ ). notar que
no espaço plano, a equação acima dará valor de zero para a curvatura. Riemanniano
A curvatura, como explicado acima, é definida como um desvio do vetor que é paralelo
transportado em torno de um laço em um pequeno paralelogramo. Também pode ser pensado como um
coleção de curvaturas de Gauss pertencem a vários subplanos. Dado dois não paralelos
vetores S e T, a seguinte quantidade calculada usando o tensor de curvatura de Riemann
é igual à curvatura gaussiana:

kGauss = Rÿÿÿÿ SÿT ÿ SÿT ÿ. (24)

Portanto, a curvatura Riemanniana é igual à curvatura Gaussiana dos tempos do subespaço

a área ao quadrado do paralelogramo ST. A curvatura de Ricci é a contração do Riemanniano
curvatura e pode ser considerada como a média da curvatura de Riemann entre os subplanos.

3.3 Processamento de Sinal em Gráficos

Os gráficos podem capturar dados espaciais e topológicos [7]. Exemplos incluem computação gráfica,
redes de sensores sem fio, imagens, análise de rede de citações, visão computacional (correspondência
de objetos 3D), gráficos podem ser usados para representar variedades.
Não abordamos a caracterização de redes neurais por meio de gráficos nas seções posteriores,
mas dar uma visão geral das técnicas de processamento de sinal para realizar o aprendizado profundo de
gráficos nesta seção
Suponha que G = (V, E, W) é um grafo, onde V representa os vértices, E as arestas
e W os pesos atribuídos às arestas. Também assumimos grafos não direcionados. Então
suponha
Machine Translated by Google

38 P. Kaul e B. Lall

– Sinal de vértice é g(i) : V ÿ R.

– Sinal gráfico é [g(1), g(2)...g(N)].

Deixe t definir a Matriz de Adjacência. É dado como

t = D ÿ N. (25)

Aqui D é uma matriz de graus diagonal, que representa o número de arestas conectadas em
cada vértice, e N é a matriz de pesos que representa a força de cada aresta. Para um gráfico
em anel, isso consistiria em

20.000
ÿ 02000 ÿ
ÿ

D= ÿ ÿ 00200 ÿ ÿ ÿ

00020 ÿ

ÿ 00002 ÿ

uma vez que cada vértice está conectado a dois outros vértices, e

01000
ÿ 10100 ÿ
ÿ

N= ÿ ÿ 01010 ÿ ÿ ÿ

00101 ÿ

ÿ 00010 ÿ

pois em um grafo em anel apenas os vértices adjacentes são conectados.

Os autovetores de um gráfico de anel correspondem à base de Fourier. No entanto, para
gráficos mais gerais como o diagrama gráfico de Peterson mostrado na Fig. 9 , precisamos
encontrar os autovetores de t.
Deixe os autovalores serem representados como 0 ÿ ÿ1 ÿ ÿ2 ÿ ... ÿ ÿmax . Seja o eigen
, você(1) , ..., u(nÿ1) . Então o gráfico da transformada de Fourier é
vetores sejam representados como u(0)
representados como
N
ÿl
gˆ(ÿl) = g(i)u(i) , (26)
i=1

e o gráfico da Transformada Inversa de Fourier é dado por

N-1
g(i) = gˆ(ÿl)u(i) ele
. (27)
l=0

O problema com a transformada de Fourier do gráfico definida acima é que muitos operadores no
processamento de sinal tradicional não estão diretamente disponíveis. Alguns exemplos incluem:

– A tradução, por exemplo, f (t ÿ 3) é bem definida no processamento tradicional de sinais. No

entanto, os vértices são atribuídos arbitrariamente e a tradução será mal definida em um gráfico.
Machine Translated by Google

Caracterização Teórica de Redes Neurais Profundas 39

Fig. 9 Gráfico de Petersen com valor de sinal positivo aleatório mostrado como a altura da barra no topo
cada vértice

– A modulação, por exemplo , e2ÿiÿ0t f (t) também está bem definida. No entanto, o espectro próprio não é
contínuo.
– Downsampling implica reduzir as amostras, mas o que cada outro vértice
significar no contexto do gráfico.

Por exemplo, a multiplicação no domínio espectral do gráfico é definida como

gˆout(ÿl) = ˆgin(ÿl)hˆ(ÿl). (28)

A filtragem correspondente também pode ser feita no domínio do vértice

gota(i) = bi,igin(i) + bijgin (j). (29)

i,jÿN(ik)

A convolução clássica é definida como

( f ÿ h)(t) = f (ÿ )h(t ÿ ÿ )dÿ . (30)

R

Isso não pode ser generalizado diretamente devido ao termo h(t ÿ ÿ ), que envolve uma tradução.
No entanto, podemos definir

N-1
(g ÿ h)(i) = gˆ(ÿl)hˆ(ÿl)u(i) l . (31)
0

O que impõe a convolução no domínio do vértice é igual à multiplicação no gráfico

domínio espectral para algumas constantes {bi,j}i, j ÿ V A convolução não pode ser feita em
Machine Translated by Google

40 P. Kaul e B. Lall

domínio do vértice, mas pode ser feito no domínio espectral. Soluções semelhantes podem ser
feitas para modulação, dilatação, engrossamento e downsampling. Finalmente, as CNNs podem ser
treinadas utilizando as definições de operador acima e utilizando convoluções no domínio da frequência.

4 Caracterização por Complexidade Homológica

4.1 Números Betty

Seja fN : RN ÿ R representar uma rede neural feed-forward de classificador binário com N entradas
e saída única. Então a complexidade de fN pode ser pensada como a complexidade topológica do
conjunto SN = x ÿ Rn| fN (x) ÿ 0. Essencialmente, este conjunto representa todas as entradas para
as quais a rede neural feed-forward dá uma classe positiva.
Para qualquer subconjunto S ÿ Rn, existem n números Betti denotados por bi(S), 0 ÿ i ÿ n ÿ 1. O
primeiro número Betti pode ser pensado como o número de componentes conectados no conjunto,
enquanto o i-ésimo O número de Betti é o número de buracos de dimensão (i + 1) em S. Por
exemplo, tanto a Esfera (Sÿ) quanto o Toro (Sÿ ) têm o primeiro número de Betti b0 = 1, pois ambos
têm um único componente conectado. O segundo número de Betti para a esfera b1(Sÿ) é 1, mas
para o toro b1(Sÿ ) é 2. Para a esfera existe um único furo bidimensional, pois apenas um único
círculo (deformável) pode ser desenhado em sua superfície . No entanto, para o toro, existem dois
orifícios bidimensionais, sendo o primeiro o círculo que pode ser desenhado sobre o orifício central
do toro e o segundo sendo aquele que pode ser desenhado através do tubo cilíndrico que forma o
toro (ver Fig. 10). Estes dois orifícios não são mutuamente deformáveis um ao outro.

Os números de Betti representam a noção topológica de complexidade. Em particular, a soma

dos números de Betti de uma região SN , representando as regiões classificadas positivamente de
uma rede neural é dada por B(SN ) = Bi(SN ). Isso pode
complexidade
Ei
ser usado como
de regiões
uma medida
de classificação
de de
uma rede neural.

Fig. 10 Esfera (esquerda) e Torus (direita)

Machine Translated by Google

Caracterização Teórica de Redes Neurais Profundas 41

Tabela 1 Limites superior e inferior do crescimento de B(SN ), para redes com h neurônios ocultos, n
entradas e as camadas ocultas . Arquitetura com muitas camadas será chamada de profunda, arquiteturas com
uma camada oculta será chamada de superficial. Tabela retirada de [5]
entradas Camadas ocultas Função de ativação Vinculado

Limites superiores
n 1 limite O(hn)
n 1 Arctan OU((n + h)n+2)
1
n 1 Polinômio, grau r 2
(2 + r)(1 + r)n+1
1 1 Arctan horas

n Muitos Arctan 2h(2hÿ1)O((nl + n)n+2h )

n Muitos oh 2h(hÿ1)/w OU((nl + n)n+h )
1
n Muitos Polinômio, grau r dois
(2 + rl )(1 + rl )(nÿ1)

Limites inferiores
hÿ1 n
n 1 Qualquer sigmóide n
n Muitos Qualquer sigmóide
2lÿ1

n Muitos Polinômio, grau r ÿ 2 2lÿ1

Limites superior e inferior para a soma dos números de Betti para um feed-forward neural
rede em função do número de camadas l, número de neurônios ocultos n e
número de entradas n, é derivado em [5]. A tabela com vários números de camadas e
funções de ativação é dada na Tabela 1.
A existência do limite inferior L implica que existe pelo menos uma rede N que
pertence à classe e para a qual B(SN ) < L vale, enquanto a existência de um
limite superior implica que U vale para todas as redes da classe, ou seja, B(SN ) > U para todas
redes.
Duas proposições importantes que são sugeridas a partir das tabelas.

Proposição 4.1 Para redes neurais feed-forward com uma única camada oculta, o
soma dos números Betti cresce na taxa polinomial no máximo com o número de números ocultos
unidades h, ie B(SN ) ÿ O(hn).

Proposição 4.2 Caso haja mais de uma unidade oculta, B(SN ) cresce exponencialmente com
o número de unidades ocultas, ou seja, B(SN ) ÿ ÿ(2h).

As proposições acima também estão interligadas com a dimensão Vapnik-Chervonenkis

(dimensão VC) [43]. Foi comprovado que a dimensão VC para redes neurais funciona com
arctan(·) ou tanh(·) é O(p2) [3]. Assim, a dimensão VC é polinomial
em relação ao número de parâmetros e independente do número de camadas. Desde
está provado que a dimensão VC é independente do número de camadas per se, enquanto
a complexidade topológica é dependente do número de camadas, pode-se inferir que
redes neurais mais profundas (em comparação com redes neurais rasas com o mesmo número
de parâmetros) são capazes de lidar com aplicações mais complexas sem perder a generalização.
Machine Translated by Google

42 P. Kaul e B. Lall

Fig. 11 As saídas de rótulo positivo de redes neurais de camada oculta única, h12 e h26, de 2 entradas com 12
e 26 unidades ocultas, respectivamente, após treinamento nos conjuntos de dados D1 e D2 com exemplos
positivos em vermelho. As regiões destacadas da saída constituem a região de decisão positiva [17]

4.2 Seleção de Arquitetura da Homologia do Conjunto de Dados

A ideia de medir a expressividade homológica diz respeito ao seguinte problema: dado um

problema de aprendizagem (conjunto de dados), qual arquitetura é adequadamente regularizada
e expressiva o suficiente para aprender e generalizar no conjunto de dados dado. Esse problema
pode ser resolvido definindo uma medida para a complexidade do conjunto de dados e
caracterizando as arquiteturas neurais por sua capacidade de aprender sujeita a essa complexidade.
Um exemplo de dois conjuntos de dados diferentes D1 e D2, com diferentes complexidades
homológicas é dado na Figura 11. O conjunto de dados D1 fornece os exemplos positivos
amostrados dos dois discos e as amostras negativas do seu complemento. Para o conjunto de
dados D2, os pontos positivos consistem em pontos amostrados de dois discos e dois anéis com
centros ocos. Vemos que nenhuma camada oculta com ÿ12, denotada hÿ12, pode expressar os
dois buracos e clusters em D2. Por outro lado, para D1, tanto h12 quanto h26 podem expressar
perfeitamente o limite de decisão.

Definição 4.1 Dado um espaço topológico U, com números de Betti ÿn definidos como os buracos
de dimensão n, definimos a homologia como a sequência H(U) = Hn(U) com cada Hn(U) = Zÿn
sendo o n- ésimo grupo homológico. O primeiro número Betti ÿ0 corresponde ao número de
componentes conectados no espaço topológico.

Do nosso primeiro exemplo definido acima, H(D1) = {Z1, 0, 0, 0, ...} já que D1 tem 2 com
componentes conectados e sem furos de qualquer dimensão. Para o segundo exemplo, defina
H(D2) = {Z4,Z2, 0, 0, 0, ...}, pois possui 4 componentes conectados e dois furos
de dimensão 2.

4.3 Homologia Computacional

Para calcular a homologia de qualquer conjunto, temos que assumir que os pontos são amostrados
de um objeto geométrico real. Como em pequenas escalas, cada ponto de dados é isolado,
Machine Translated by Google

Caracterização Teórica de Redes Neurais Profundas 43

Fig. 12 Código de barras da homologia de persistência [42]

a homologia de qualquer conjunto discreto de pontos é trivialmente H(D) = (Z)M , 0, 0, 0... Para
resolver este problema Zomordian e Carlsson desenvolveram homologia persistente [45]
baseada na homologia de filtrações de um espaço. Especificamente, a filtragem de um espaço
X o equipa com a seqüência de subespaços X0 ÿ X1 ÿ X2... ÿ X. Uma filtragem simples envolve
o crescimento de bolas de tamanho centrado em cada ponto e deixando X como a filtragem
resultante. À medida que cresce, os vários pontos se fundem e formam objetos geométricos
conectados, levando a mudanças na homologia. Também haveria novos orifícios de várias
dimensões que são formados. Além da formação, buracos e objetos conectados podem
desaparecer ou se fundir com o crescimento.
Essa mudança nos números de Betti de X com o
crescimento é resumida no diagrama de código de barras de persistência mostrado na Fig. 12.
Na figura, o ponto final esquerdo de uma barra é o ponto em que a homologia detecta um
componente específico e a extremidade direita é onde o componente se torna indistinguível .
Suponha que D seja algum conjunto de dados extraído de uma distribuição conjunta F, no
espaço topológico X × {0, 1} e X+ denotam a distribuição de rótulos positivos e Xÿ a distribuição de rótulos negati
Então Hs( f ) denota a homologia da região de decisão positiva f (x) > 0. Finalmente seja F = f :
X ÿ 0, 1 uma família de classificadores binários em X.

Teorema 4.3 Generalização Homológica. Se X = Xÿ1 ÿ X+1 e para todo f ÿ F com Hs( f ) =
H(X+), então para todo f ÿ F existe A ÿ X+ então f classifica erroneamente todo x ÿ A.

4.4 Medições Empíricas

Os autores em [17] treinam redes totalmente conectadas com funções de ativação ReLU com
pesos de cada arquitetura inicializados para amostras de distribuição normal
N(0, ÿ01 )
Machine Translated by Google

44 P. Kaul e B. Lall

Fig. 13 Tabela de probabilidades estimadas de diferentes arquiteturas neurais para expressar certas
características homólogas dos dados após o treinamento. Acima: as probabilidades de homologias expressas com
ÿ0 em função de camadas e neurônios. Abaixo: As probabilidades de expressar ÿ1 ÿ {1, 2} como um
função de camadas e neurônios [17]

Eles medem o erro de classificação incorreta ao longo do treinamento e o homo

expressividade lógica no final do treinamento, com o termo posterior definido como

ÿp( f )
E p ( f, D) = min , 1 . (32)
H
ÿp(D)

A quantidade acima mede a capacidade do modelo para exibir a verdadeira homologia de

dados. A análise de convergência de várias redes neurais sugere que elas exibem uma
transição de fase topológica estatisticamente significativa durante o aprendizado que depende de
a complexidade homológica dos dados. Para qualquer conjunto de dados o melhor erro de arquiteturas
com l camadas e h unidades ocultas é estritamente limitado em magnitude e tempo de convergência
pela fase h . Os autores conjecturam a partir dos dados experimentais (ver Fig. 13) que

ele

fase h ÿ C ÿ0D. (33)

Também para selecionar uma arquitetura (l, h0) fase h limitante inferior, e restringindo
a análise para redes de camada única uma estimativa de limite inferior é obtida dada por

ele

fase h (ÿ0,ÿ1) ÿ ÿ1C ÿ0(D) + 2. (3. 4)

Machine Translated by Google

Caracterização Teórica de Redes Neurais Profundas Quatro cinco

5 Caracterização por Transformada de Espalhamento

5.1 Visão geral

Uma série de artigos de Stephane Mallat [2, 28, 29] e equipe utilizaram
teoria e transformações de espalhamento para analisar redes de aprendizado profundo, assumindo alguns
simplificações. A aprendizagem supervisionada pode ser definida como um método para estimar a
função de mapeamento entre dados de entrada e rótulos gerados, utilizando dados de treinamento
que é fornecido. Sejam q amostras de dados de treinamento, a função estimada seja ˜f (x) e a função
real seja f (x), e ÿ seja um subconjunto de Rd que é o padrão ,
Espaço euclidiano d -dimensional. Então:

{xi , f (xi )}iÿq para x = (x(1), ...x(d)) ÿ ÿ. (35)

Para problemas de regressão, f (x) está em R e para classificação f (x) é índice de classe
dentre todos os índices de classe possíveis. Este problema fica mal definido se não fizermos
suposições adicionais sobre f . O número de pontos N( ) que precisamos observar para garantir
ÿd . de maldição de dimensionalidade
que | f (x) ÿ f (x )| ÿ is ÿ Esta é, uma instância
implicando que o número de amostras necessárias cresce exponencialmente com a dimensão
de dados D. No entanto, se houver propriedades de regularidade conhecidas em f , ainda poderemos
estimar f (x) sem número exponencial de amostras. Assumindo que
f é Lipschitz. Ou seja, a taxa de variação da saída com a entrada é limitada, é a mais simples
suposição de regularidade. Exigimos formalmente:

ÿC st ÿ(x, x )| f (x) ÿ f (x )| ÿ C||x ÿ x ||. (36)

Podemos possivelmente encontrar um operador contrativo ÿ, tal que ÿ(x) reduza a variabilidade
de x . No entanto, o operador ÿ deve ser restringido de tal forma que x pertencentes a diferentes
classes ainda sejam separados após a contração, ou seja, ÿ(x) = ÿ(x ) se f (x) = f (x ).
Se a função é constante em certas direções, então podemos realizar a redução da dimensionalidade
projetando para um subespaço dimensional inferior. Caso contrário, precisamos
para linearizar x através de transformações não lineares ÿ(x) de modo que o f (x) permaneça
constante em certas direções. A redução da dimensionalidade para o subespaço inferior pode
então ser realizado. Efetivamente, precisamos encontrar ÿ(x) tal que ˆf (x) seja o mais próximo
estimativa de f (x) possível.

ˆf (x) = p(y = 1|x) = ÿ(wT ÿ(x) + b) (37)

Isto implica que ÿ(x) irá linearizar f (x) e o seguinte é válido.

aT (ÿ(x) ÿ ÿ(x )) = 0 =ÿ f (x) = f (x ). (38)

Machine Translated by Google

46 P. Kaul e B. Lall

Para classificação, isso implica que mantemos a distância mínima entre as diferentes
classes.

ÿ ÿ 0 ÿ(x, x ) ÿ ÿ2 , |(|ÿ(x) ÿ ÿ(x )|)| ÿ se f (x) = f (x ) (39)

5.2 Invariantes e Simetrias

Como os dados de entrada estão em variedades altamente curvas, f linearizará a entrada
sucessivamente através das camadas. Como a classificação mapeia regiões nas variedades
de entrada para índices específicos, essas regiões podem ser consideradas como conjuntos
de níveis definidos como ÿt = x : f (x) = t, onde f é contínuo. Como na camada final podemos
linearizar totalmente a entrada e mapear diferentes classes para diferentes hiperplanos, o w
aprendido é tal que f (x) é aproximado por < ÿ(x), w >. Também se x pertence à classe t, então < ÿ(x), w >ÿ t.
A simetria global pode ser pensada como um operador ÿ que deixa f invariante:

ÿx ÿ ÿ, f (ÿ(x)) = f (x) (40)

O impacto das simetrias pode ser de duas formas distintas, mas relacionadas:

(i) Invariância: ÿ(ÿ(x)) = ÿ(x) para cada x (ii)

Equivariância: ÿ(ÿ(x)) = ÿ(ÿ(x)) para cada x, ÿ

Para satisfazer o acima, precisamos de operadores invertíveis g tais que deixem o valor de
f inalterado ie f (gx) = f (x) para todo x ÿ ÿ. Notamos que a composição de duas simetrias
globais g1 e g2 é também uma simetria global g1.g2. Como uma identidade e um elemento
inverso estão sempre presentes, e o fechamento de grupo se mantém, essas simetrias formam
um grupo. Tais variedades diferenciáveis com uma estrutura de grupo são chamadas de grupos
de Lie [14]. Dizemos que G é um grupo de simetrias locais de f se:

ÿx ÿ ÿ, ÿCx > 0, ÿg ÿ G com |g|G < Cx , f (gx) = f (x) (41)

Exemplos de simetrias para imagens incluem

(i) Traduções {ÿv,; v ÿ R2}, com ÿv(x)(u) = x(u ÿ v). (ii) Dilatações
{ÿs;s ÿ R+}, com ÿs(x)(u) = sÿ1x(sÿ1u). (iii) Rotações {ÿÿ; ÿ ÿ [0, 2ÿ]},
com ÿÿ(x)(u) = x(Rÿu). (iv) Simetria Espelhada: {e, M}, com M x(u1,
u2 ) = x(ÿu1, u2 ).

Todas as transformações acima podem ser combinadas no grupo afim Aff (R2) com 6 graus
de liberdade na representação.
Machine Translated by Google

Caracterização Teórica de Redes Neurais Profundas 47

5.3 Tradução e Difeomorfismos

As simetrias globais são difíceis de encontrar, então primeiro usamos simetrias locais. Estes
podem ser modelados como um grupo de traduções e difeomorfismos que deformam os sinais
localmente. Em aplicações de reconhecimento de imagem e fala, não existem grupos de simetria
de alta dimensão, no entanto, a estabilidade às deformações locais é esperada (ver Fig. 14). deixar

x ÿ L2 (Rm), ÿ : Rm ÿ Rm. (42)

Então
xÿ = ÿÿ (x), xÿ (u) = x(u ÿ ÿ (u)). (43)

onde ÿÿ é uma mudança de variáveis. O termo xÿ está deformando as localizações dos pixels,
em vez dos próprios pixels.
O grupo de Lie mais simples de transformações é o grupo de tradução G = Rn. A ação de g ÿ
G = Rn sobre x ÿ ÿ é gx = x(u ÿ g). Como as traduções são definidas por um número limitado de
parâmetros (apenas dois nas imagens, deslocamentos nas dimensões xey), essas simetrias não
são muito poderosas. Também as simetrias de difeomorfismo são específicas da aplicação e do
conjunto de dados, por exemplo, no caso de dígitos MNIST, algumas transformações deixam o
dígito inalterado enquanto outras o alterariam [25]. Para linearizar a simetria local usamos a
transformação ÿ(x) que lineariza a ação de g ÿ G localmente. Por definição, ÿ é contínua de
Lipschitz se

ÿC > ÿ(x, g) ÿ ÿ × G, ||ÿ(gx) ÿ ÿ(x)|| ÿ C|g|G||x|| (44)

Aqui |g|G mede a diferença entre g ÿ G e identidade e é a norma euclidiana de g ÿ Rn.

Notamos que um operador limitado g aproxima ÿ(x) ÿ ÿ(gx) se a norma de g for suficientemente
pequena.

Fig. 14 Deformações locais em uma imagem [8]

Machine Translated by Google

48 P. Kaul e B. Lall

5.4 Contração e Separação de Escala por Wavelets

Para avaliar a estabilidade, primeiro precisamos quantificar a quantidade de deformação. Também,

precisamos encontrar uma noção de escala: em muitas aplicações, estamos interessados em
invariância em vez de invariância de grupo global. As redes convolucionais profundas são
covariante em vez de invariante às traduções. Portanto, a tradução na entrada leva a
traduções na saída para camadas convolucionais. No entanto, para fazer o cálculo
invariantes às traduções, as escalas precisam ser separadas e as não linearidades precisam ser
aplicado. Um operador linear calcula invariantes locais para a ação do grupo de tradução G.
Isto é feito tomando a média de x na órbita {gx}gÿG. Isso é feito por convolução
com um kernel ÿJ (u) = 2ÿn Jÿ(2J u) de tamanho 2J com ÿ(u)du = 1:

ÿJ x(u) = x ÿJ (u). (Quatro cinco)

Isto é verificável que a média é Lipschitz contínua a difeomorfismos para

todos x ÿ L2(Rn) em uma faixa de translação 2J . No entanto, elimina variações no
entrada acima da frequência 2J . Se J = ÿ elimina quase todas as informações.
Usamos wavelets de diferentes escalas para separar variações em diferentes escalas.
K wavelets são definidas ÿk (u) de u ÿ Rn. Estes são dilatados por 2j : ÿj,k (u) =
2ÿ jnÿk (2ÿ j u). Usando convoluções com wavelets podemos calcular a média de
x nas escalas 2J e variações nas escalas 2j ÿ 2J de tração . Esta operação de convolução é con
e a representação obtida é esparsa. Para sinais de áudio n = 1 e K =
12 frequências intermediárias são usadas dentro de oitava 2J . Para imagens n = 2, usamos
k
orientações que são giradas. por exemplo, usamos J = 4, K = 4, como mostrado na Fig. 15.
K

5.5 Banco de Filtros, Remoção de Fase e Contrações

Usamos uma cascata de filtros em diferentes escalas para calcular a forma trans de espalhamento
com wavelets. Em cada escala usamos filtros wj,k que calculam as wavelets
ÿj,k = wj,k ÿ ÿjÿ1. Além disso, em cada estágio, realizamos a média em uma escala aumentada por
utilizando o filtro wj,0 para calcular ÿj = wj,0 ÿ ÿjÿ1. Coeficientes wavelet x j(u, k) =
x ÿ ÿj,k (u) oscilam na escala 2j , e a média de xj com ÿj produziria um sinal zero. Portanto, não
linearidades são necessárias para remover oscilações. Módulo(ÿ(ÿ) = |ÿ|)
é uma tal não-linearidade que calcula o envelope positivo. Também podemos usar
o ReLU dado por max(m,0), que também é um operador de contração semelhante ao modus. Qualquer
operador não linear para o qual |ÿ(ÿ) ÿ ÿ(ÿ )|ÿ|ÿ ÿ ÿ | pode ser considerado
contrativo. Média (ÿ(x ÿ ÿj,k (u)) com ÿJ coeficientes positivos de saída que são
localmente invariante em escala 2J . Exemplos de invariantes locais multiescala são mel-espectro em
fala e SIFT em imagens. Eles têm perda de informações devido à média e, portanto,
são calculados em pequenas escalas (por exemplo, 162 pixels para SIFT). Por isso não capturam
estrutura de grande escala e também falham em capturar interações de escala. transformação de espalhamento
usando operadores de módulo wavelet é mostrado na Fig. 16.
Machine Translated by Google

Caracterização Teórica de Redes Neurais Profundas 49

Fig. 15 Filtros Wavelet [29]

5.6 Grupos de Tradução

As redes neurais profundas são compostas por uma cascata de filtros lineares (convolução ou
totalmente conectadas) camadas intercaladas com não linearidades pontuais ÿ. Pela simplicidade,
uma arquitetura onde o filtro convolucional não adiciona nos canais de entrada é
usado.

Suponha que x j(u, k j) seja calculado pela convolução de canal único x jÿ1(u, k jÿ1)
ao longo de u, onde j é o índice da camada. Então

x j(u, k j) = ÿ(x jÿ1(., k jÿ1) ÿ wj,h(u)) com k j = (k jÿ1, h). (46)

Iterando sobre j define uma árvore de convolução

xJ (u, kJ ) = ÿ(ÿ(ÿ(ÿ(x ÿ w1,h1 ) ÿ ...)ÿ) ÿ wJÿ1,hJÿ1 )) ÿ wJ,hJ )). (47)

Para m = 1, os coeficientes xJ (u, kJ ) = ÿ(x ÿ ÿj1,k1 ) ÿ ÿJ (u) são os coeficientes wavelet. Para m =
2, ÿ(ÿ(x ÿ ÿj1,k1 ) ÿ ÿj2,k2 ) ÿ ÿJ (u) são invariantes complementares
medindo interações de x na escala 2j1 dentro de uma distância 2j2 e ao longo da orientação
e bandas de frequência definidas por k1 e k2. Veja a Fig. 17. Note-se que em caso de
imagens e fala a maior parte da energia está contida nos dois primeiros estágios, ou seja, m ÿ 2.
Se x é estacionário que ÿ(...ÿ((x ÿ ÿj1,k1 ) ÿ ÿj2,k2 ...) permanece estacionário porque
convoluções e operadores pontuais preservam a estacionariedade. Para um retificador ou módulo
ÿ(ÿ) = ÿ para ÿ ÿ 0. Assim, o ÿ na saída do filtro de média pode ser removido. Para uma banda-
Machine Translated by Google

cinquenta P. Kaul e B. Lall

Fig. 16 A transformada de espalhamento inclui operadores wavelet seguidos por operadores de módulo em
cascata formando uma estrutura em árvore. Em cada estágio, os coeficientes também são calculados através do
operador passa-baixa ÿ [2]

Fig. 17 Coeficientes de dispersão

passe o filtro a não linearidade remove a fase ou sinal, que tem forte efeito de contração.
Podemos remover ÿ de todos os filtros passa-baixa, então a cascata de convoluções J
se reduz a m (número de filtros passa-faixa).
Machine Translated by Google

Caracterização Teórica de Redes Neurais Profundas 51

Fig. 18 Espalhamento inverso comparado ao processo Gaussiano. Primeira linha: texturas originais. Segunda linha:
processo gaussiano com covariância idêntica à primeira linha. Terceira linha: espalhamento inverso realizado com as
duas primeiras ordens de coeficientes de espalhamento [29]

5.7 Espalhamento Inverso e Esparsidade

Transformações de espalhamento não são inversíveis. No entanto, para um dado ÿJ (x) podemos
tentar encontrar x˜ tal que ||ÿJ (x) ÿ ÿJ (x˜)|| < Isso
ÿJ . pode ser conseguido inicializando x˜0 com ruído
branco gaussiano e usando gradiente descendente enquanto tenta reduzir ||ÿJ (x) ÿ ÿJ (x˜n)||. Na Fig.
18, a primeira linha é a textura original. A segunda linha mostra um processo gaussiano com a mesma
covariância que a textura original na primeira linha. A terceira linha mostra o espalhamento inverso
como descrito acima usando coeficientes de espalhamento com ordem m <= 2, 2J = N e K = 8. Como
pode ser visto na Fig. 18, os coeficientes de espalhamento são capazes de reproduzir muito mais
semelhança na textura do que Processo gaussiano com dois primeiros momentos idênticos à figura
original.

6 Caracterização por Curvatura

6.1 Teoria do Campo Médio e Curvatura Gaussiana

O método descrito em [34] analisa redes neurais profundas usando uma combinação de curvatura
Riemanniana e teoria de campo médio. Para simplificar a análise, eles assumem que as redes neurais
têm pesos aleatórios. A intuição que conduz aqui é que DNNs podem representar funções aleatórias
genéricas. A DNN também pode separar manifolds curvos na entrada em manifolds planos na saída.
Finalmente redes neurais mais profundas
Machine Translated by Google

52 P. Kaul e B. Lall

com o mesmo número de neurônios pode fazer esse desembaraçamento de forma mais eficaz do que
redes rasas.
Considere uma DNN com D camadas de pesos w1...wD e D + 1 camadas de vetores
x 0, ...x eDwlcom
ÿ RNl×Nlÿ1 w e polarizações
Nl neurônios na camada l,blxl ÿ RN . A saída do filtro
ele

, com não linearidade ÿ na camada l, para uma entrada x 0 são dados é dado por:

xl = ÿ(hl ), hl = wl xlÿ1 + bl (48)

Aqui hl é a saída do filtro na camada l, e ÿ é uma não linearidade pontual que atua
em hl para gerar xl . Os pesos e vieses são inicializados com aleatório gaussiano
variáveis distribuídas da seguinte forma:

– wl ÿ N(0, ÿ2 ÿ/Nlÿ1).
eu j

– b ÿ N(0, ÿ2 b
).

À medida que uma variedade simples se propaga através da rede neural, a modificação em
sua geometria deve ser medida. O comprimento quadrado normalizado na entrada de
camada l é definida como
nl
1
ql = ( eu)
dois

(49)
nl
lÿ1

Através do teorema do limite central, esta quantidade irá convergir para zero médio gaussiano
variável aleatória para Nl grande . Como esta distribuição é processada através das camadas e
mapa iterativo de ql baseado no índice de camada l pode ser obtido na Eq. 49

ql =V(qlÿ1 |ÿÿ, ÿb) = ÿ2 ÿ

Dzÿ( qlÿ1z) + ÿ2 b
para l = 2, ..., D, (cinquenta)

Onde
dz
Dz = eÿz2/2 (51)
ÿ2ÿ

é a medida gaussiana padrão e z é uma variável dummy e a condição inicial é

q1 = ÿ2wq0 + ÿ2 _ b (52)

e q0 representa o comprimento até a primeira camada definida como

1
q0 = x 0 x 0 . (53)
N0

A função V (na Eq. 50) é a variância iterativa, que prevê a mudança de comprimento como
entrada passa pela rede. É uma função côncava cuja interação com
linha unitária determina seus pontos fixos qÿ(ÿÿ, ÿb). Como pode ser visto na Fig. 19
Machine Translated by Google

Caracterização Teórica de Redes Neurais Profundas 53

Fig. 19 Variação de ql quadrado para rede com não linearidade tanh e 1000 unidades ocultas. a E o mapa de
comprimento foi mostrado para diferentes ÿw em ÿb. As linhas sólidas representam previsões teóricas enquanto
os resultados da simulação são mostrados com pontos. Os pontos fixos qÿ do mapa são mostrados como
estrelas. b O mapa de comprimento muda através das camadas e converge dentro de algumas camadas para
qÿ em todos os casos (linhas=teoria; pontos=simulação). c O ponto fixo é mostrado em função de ÿw e ÿb. d
Número de camadas em que o desvio fracionário do ponto fixo é menor que um. Os pares (ÿb; ÿw) em (a, b)
são marcados com círculos de cores combinadas em (c, d) [34]

1. para ÿb = 0, ÿÿ < 1, a única interseção é qÿ = 0 e, portanto, a rede reduz todas as entradas a

zero. 2. para ÿw > 1 e ÿb = 0, qÿ = 0, o ponto fixo torna-se instável e o mapa de comprimento
adquire um segundo ponto fixo diferente de zero, mas estável, e a rede contrai grandes entradas
e expande pequenas entradas. 3. para qualquer viés não nulo ÿb o mapa de comprimento
tem um único ponto fixo não nulo estável. Neste caso, a polarização injetada evita que o
sinal decaia para zero.

Transiente: Se considerarmos duas entradas, x duas entradas

0,1 e x 0,2,
podema geometria
ser representadas
desses Caos
por
uma matriz 2 × 2 para produtos internos dada por.

1 nl
= hl i(x 0,a)hl i(x 0,b) a, b ÿ 1, 2. (54)
qlab N
i=1

Os termos q1 e ql
onze 22 é o comprimento que pode ser inferido diretamente da Eq. 50. Para o
termos não diagonais, um mapa de correlação C pode ser inferido para ql 12:

ql12 = C(clÿ1
12 , qlÿ1
11 , qlÿ1
22 |ÿÿ, ÿb)

= ÿ2 Dz1Dz2ÿ(u1)ÿ(u2) + ÿ2 b,
ÿ

Onde

u1 = qlÿ1 11z1 , (55)

clÿ1
12 z1 + 1 ÿ (clÿ1 )2z2 (56)
u2 = qlÿ1 22 12 ,
Machine Translated by Google

54 P. Kaul e B. Lall

Fig. 20 Variação da correlação, cl à medida

12, que passa por camadas na rede ponderada aleatoriamente
com tanh não linearidade. a O C-map é mostrado para o caso ÿw e ÿb = 0,3 como na Fig. 19. b A
mudança no C-map é mostrada. As linhas sólidas são teoria enquanto os pontos são para simulações
usando Nl igual a 1000. c Pontos fixos cÿ do C-map. d A inclinação do C-map em 1, ÿ1, divide o
espaço (linha pontilhada preta em ÿ1 = 1) em regiões caóticas (ÿ1 > 1, cÿ < 1) e ordenadas (ÿ1 < 1, cÿ
= 1) [3. 4]

e o coeficiente de correlação é definido como:

cl 12 = ql 12(ql 11ql 22) ÿ1/2 . (57)

Aqui z1 e z2 são variáveis gaussianas não correlacionadas, enquanto u1 e u2 são correlacionadas

Variáveis gaussianas com matriz de covariância < uaub >= qlÿ1 ab .
Como o comprimento de cada ponto converge rapidamente para qÿ(ÿÿ, ÿb) à medida que nos propagamos através
a rede podemos substituir este valor. Podemos calcular cÿ definindo ql qÿ(ÿÿ, ÿb) e onze
= ql 22 =
dividindo por qÿ. Podemos assim obter um C-map (mapa de coeficiente de correlação):

1
cl 12 = (58)
C(clÿ112 , qÿ, qÿ|ÿÿ, ÿb). qÿ

O C-map sempre tem um ponto fixo cÿ = 1. A estabilidade do ponto fixo depende da inclinação do
mapa em 1, que é

ÿcl
12 dois
.
= ÿclÿ1 |c=1 = ÿ2 ÿ1ÿ Dz[ÿ ( qÿz)]
12

Então, três regiões são possíveis com base no valor de ÿ1 (veja a Fig. 20):

– para ÿÿ pequeno, cÿ = 1 é o único ponto fixo e é estável quando ÿ1 < 1 e quaisquer dois pontos
convergem à medida que se propagam pela rede. – à medida que ÿÿ aumenta, ÿ1 cruza 1 e um
novo cÿ é criado, diferente de 1. – para ÿÿ maiores os pesos fortes superam os vieses tornando a
entrada descorrelatada e ortogonal, levando a um ponto fixo estável em cÿ = 0.

Portanto , ÿ1(ÿw, ÿb) = 1 produz um limite de transição de fase no plano (ÿw, ÿb) separando-o
em fase caótica e fase ordenada com base na separação/convergência.
Notamos que log ÿ1 é o expoente de Lyapunov na teoria de sistemas dinâmicos.
Machine Translated by Google

Caracterização Teórica de Redes Neurais Profundas 55

Propagação através de Deep Net. Agora podemos tentar rastrear o comprimento de uma variedade à
medida que ela se propaga através de uma rede neural profunda. Na primeira camada

0
hl (0) = hl (x (ÿ)), (59)

onde x 0(ÿ) é uma variedade 1-D com ÿ sendo coordenadas intrínsecas do scaler. Podemos
escolher um círculo definido como:

N1q u0 cos (ÿ) + u1 sen(ÿ) , (60)

onde u0 e u1 são bases ortonormais para o subespaço bidimensional do ponto RN , a . em cada

variedade h(ÿ) tem tangente ou vetor velocidade.

v(ÿ) = ÿÿ(h(ÿ)). (61)

A curvatura está relacionada com a aceleração que é definida como a taxa de variação da velocidade.

a(ÿ) = ÿÿ(v(ÿ)) (62)

Em cada ponto ÿ, v(ÿ) e a(ÿ) abrangem um espaço 2D de . O círculo osculador é definido

RN como um círculo com raio R(ÿ) tal que tem a mesma posição, velocidade e aceleração que
h(ÿ) em ÿ

A curvatura extrínseca é definida como

1
k(ÿ) = , (63)
R(ÿ)

Também a curvatura extrínseca está relacionada à velocidade e aceleração como:

k(ÿ) = vv ÿ 3/2 (vv)(aa) ÿ (va)2. (64)

O comprimento total da curva de acordo com a métrica euclidiana é

LE = gE (ÿ)dÿ. (65)

Onde
gE (ÿ) = v(ÿ).v(ÿ). (66)

Para a variedade k dimensional M embutida em RN o mapa de Gauss mapeia um ponto ÿ ÿ

M ao seu plano tangente k dimensional TÿM ÿ Bk,n onde Bk,n é a variedade Grassmaniana de
todos os espaços k-dimensionais. O Mapa de Gauss pega um ponto ÿ na curva e o mapeia para
o vetor de velocidade unitária v(ˆ ÿ) = v(ÿ)/ÿv(ÿ).v(ÿ). A métrica de Gauss está relacionada à
curvatura extrínseca e às métricas euclidianas por
Machine Translated by Google

56 P. Kaul e B. Lall

dois

gG(ÿ) = k(ÿ) gE (ÿ). (67)

O comprimento da curva sob o Mapa de Gauss é

LG = gG(ÿ)dÿ. (68)

A curvatura extrínseca e a métrica euclidiana mudam iterativamente à medida que se propagam

pelas camadas como

gE,l = ÿ1gE,lÿ1 ,

ÿ2 1
2 = 3 + ÿ1 dois

(kl ) ÿ1 (klÿ1 ) ,

gE,l = qÿ,
dois

(k1 ) = 1/ qÿ,

dois dois

ÿ2 = (ÿÿ) Dz[ÿ ( ÿqz] ,

onde ÿ2 é definido analogamente a ÿ1.

Se o círculo é ampliado, ou seja, hÿ = ÿh(ÿ), então o comprimento de L eEo raio aumentam em ÿ,
mas as curvaturas são dimensionadas em ÿÿ1, então LG não muda. No entanto, em redes profundas
este não é o caso e a LG também aumenta. Em redes neurais sigmoidais a evolução se comporta
de forma diferente dependendo do valor de ÿ1.
Para a fase caótica ÿ1 > 1: A métrica euclidiana gE cresce exponencialmente com a profundidade
devido ao alongamento multiplicativo através de ÿ1. O alongamento atenua qualquer curvatura na
camada l ÿ 1 pelo fator de 1/ÿ1 , mas uma nova curvatura é adicionada devido a ÿ2, devido à não
linearidade de um único neurônio. Assim, diferentemente da expansão linear, a curvatura extrínseca
não é perdida, mas se aproxima de kÿ. Isso implica que a medida de curvatura global LG cresce
exponencialmente com a profundidade (ver Fig. 21).
Isso mostra que as DNNs se tornam funções altamente curvas, permitindo calcular funções
exponencialmente convexas sobre variedades simples de baixa dimensão. Além disso, o comprimento
da curva cresce exponencialmente com a profundidade, mas cresce apenas como raiz quadrada
com a largura.

6.2 Medição de Curvatura Riemanniana e Ricci

A técnica anterior baseia-se na análise da rede neural com pesos aleatórios.

No entanto, as redes do mundo real são treinadas usando gradiente descendente estocástico e,
portanto, não são verdadeiramente aleatórias. Além disso, a técnica acima não fornece uma visão
refinada do comportamento da rede neural para várias variedades multidimensionais de
transformações. Um algoritmo recente [20] que trabalha na premissa de analisar
Machine Translated by Google

Caracterização Teórica de Redes Neurais Profundas 57

Fig. 21 Um círculo múltiplo unidimensional está sendo inserido em três redes neurais diferentes com
diferentes ÿw e ÿb fixo = 0,3. um PCA é usado para projetar as saídas da camada oculta em simulações
para um subespaço tridimensional para plotagem. Apenas as camadas 5, 10 e 15 são mostradas. O
gráfico inserido mostra a energia relativa dos primeiros cinco componentes principais. Para ÿw = 4, os
valores singulares de energia máxima são distribuídos mais uniformemente e o círculo fica mais
emaranhado a cada camada sucessiva. b A variação na autocorrelação, cl 12( ÿ) = dÿql (ÿ; ÿ + ÿ)/ qÿ, é
mostrada em várias camadas. c A previsão teórica para a autocorrelação juntamente com a média e o
desvio padrão da autocorrelação medida é mostrada. De [34]

redes neurais baseadas em contexto geométrico diferencial, tenta superar essas deficiências. Ele
começa com as seguintes ideias e suposições.

1. os conjuntos de dados usados para vários problemas de aprendizado de máquina constituem

variedades de baixa dimensão incorporadas em espaços de dimensão superior. 2. o problema
de classificação envolve a segregação de variedades não lineares disjuntas dentro do conjunto de
dados. 3. essas classes na entrada estão em variedades que não são lineares e, portanto,
lineares
métodos não podem ser usados para separá-los.
4. As redes de aprendizado profundo transformam o coletor não linear de entrada, por meio de
várias transformações que ele aprende durante o treinamento para uma região linear. Em várias
arquiteturas de deep learning, essas transformações são implementadas por meio de uma
combinação de camadas lineares ou afins em conjunto com ativações não lineares. Podemos
considerar essas transformações combinadas como uma mudança de base sobre vários sistemas
de coordenadas altamente curvos.
5. uma vez que a entrada não linearizada é convertida para a região linear por meio dessas
transformações em cascata, podemos usar a técnica de projeção linear simples do tipo W x + b
(onde W é a matriz linear de pesos, x o vetor de entrada e b a polarização termo) que
efetivamente particionará os espaços através de hiperplanos.
Machine Translated by Google

58 P. Kaul e B. Lall

6. Como as transformadas são curvas sobre a base, podemos usar as ferramentas da Teoria
Geral da Relatividade que usa extensivamente a matemática da curvatura Riemanniana.

7. medimos a curvatura calculando o gradiente da saída em comparação com a aqui o é a saída

ÿo
conjunto de transformação parametrizada nos dados de entrada. Ou ÿt , eté
seja, o parâmetro de transformação.

Tentamos realizar uma medição direta da curvatura Riemanniana para uma variedade de
transformações, que podem ter uma ou mais dimensões. As transformações selecionadas
dependem do tipo de dados e, para imagens, podemos usar transformações como translação ou
rotação ou uma combinação dessas. À medida que movemos o conjunto de validação de entrada
sobre a variedade de transformações, precisamos medir o gradiente de saída usando equações
de diferença. Os passos para essas medições são mostrados na Fig. 22. Os vários passos no
são descritos anteriormente na Seção 3.2.

Classificador de Manifold Unidimensional. Testamos o algoritmo acima em um conjunto de

dados sintético e realizamos os cálculos com transformações que consistem em uma variedade
unidimensional. Alimentamos essa variedade unidimensional de entradas transformadas para um
MLP pré-treinado treinado para discriminar entre duas espirais arquimedianas.
Usamos duas espirais arquimedianas separadas por ÿ radianos, uma vez que não são linearmente
separáveis. As espirais são as dadas abaixo:

xi(ÿ) = t cos(ÿ + di) + n(ÿ), yi(ÿ) = t (69)

sin(ÿ + di) + n(ÿ), (70)

onde as duas equações geram as duas coordenadas retangulares para todos os valores do
ângulo ÿ entre 0 a 2ÿ, enquanto t é uma constante. A variável di é o ângulo inicial da espiral que
é selecionado para ser 0 para a primeira espiral e ou ÿ para a segunda espiral.
No conjunto de treinamento, também adicionamos ruído gaussiano iid às coordenadas geradas
na forma de n(ÿ).
Para gerar o conjunto de dados para a rede neural, precisamos criar um conjunto de vetores
a partir das coordenadas geradas acima. Para isso usamos dois vetores aleatórios gaussianos
com variância unitária, u0 e u1, cada um de comprimento 1000, que multiplicamos pelas
coordenadas geradas anteriormente para criar o conjunto de dados de entrada para a rede neural.

v = xi(ÿ)u0 + yi(ÿ)u1. (71)

Para criar o conjunto de treinamento, geramos ÿ aleatório para cada amostra de treinamento
a ser gerada e calculamos v usando este ÿ conforme mostrado na equação (71) acima. Este v é
o vetor de treinamento de entrada para treinar a rede neural. Uma instância particular do conjunto
de treinamento é representada na Fig. 23, onde os pontos vermelhos correspondem à primeira
classe e os pontos azuis à segunda classe. Para o conjunto de dados de validação (que será
usado para medir a curvatura), não geramos x e y através das equações espirais, mas
Machine Translated by Google

Caracterização Teórica de Redes Neurais Profundas 59

Treinamento
Treine a rede com SGD em conjunto de dados padrão

Avaliação
Crie um conjunto de dados de teste com transformações específicas e avalie
a rede treinada sobre ela, salvando os valores softmax z[i, j]

Calcular gradiente do valor softmax

ÿz(i,j)
p= ÿs = zs,t(i, j) = (ˆz[i, j] ÿ zˆ[i ÿ 1, j])/ÿs
ÿz(i,j)
q= ÿt = zt,s(i, j) = (ˆz[i, j] ÿ zˆ[i, j ÿ 1])/ÿt

Calcular a métrica usando o produto escalar de gradientes

g(p, q)=˜p(q) = p · q

Calcular símbolos de Christoffel

ÿÿ = 1/2 ÿ gÿÿ(gÿÿ,ÿ + gÿÿ,ÿ ÿ gÿÿ,ÿ)
ÿÿ

Calcule a curvatura de Riemann a partir da derivada de Christoffel Symobl

ÿ ÿ ÿ ÿ ÿ ÿ
Rÿ = ÿ ÿÿ,ÿ + ÿÿ ÿÿ
ÿÿÿ ÿ ÿÿÿ ÿ ÿ ÿÿÿ ÿÿ,ÿ ÿÿ

Calcule o tensor de Ricci

Rÿÿ = Rÿ ÿÿÿ.

Contraia o tensor Ricci para obter o scaler Ricci.

R = gÿÿRÿÿ = gÿÿgÿÿRÿÿÿÿ

Fig. 22 Etapas no cálculo da curvatura do scaler Ricci

em vez disso, gere um gird inteiro de possíveis xi e yi . Usamos então a Eq. 71 para gerar
os vetores de validação.
Depois que os conjuntos de dados são criados e a rede treinada, testamos a rede em relação ao
validação definida e armazenar os valores softmax de saída. Esta saída softmax é usada para encontrar
vários gradientes e métricas de curvatura, conforme mostrado na Fig. 22. Em primeiro lugar, notamos que o
duas classes estão na variedade unidimensional (de parâmetro ÿ), mas não são linearmente
separável. A partir das regiões do classificador plotado como mostrado na Fig. 24, pode-se inferir
que a rede discrimina corretamente entre as duas classes. A única exceção
está no centro, onde temos alguma sobreposição. Traçamos os valores do scaler Ricci para o
todo o conjunto de validação como mostrado na Fig. 25. Notamos que as redes aprendem muito grandes
valores de curvatura para as regiões limítrofes que separam as duas classes. Nós inferimos que
Machine Translated by Google

60 P. Kaul e B. Lall

Fig. 23 Conjunto de treinamento com vermelho para classe 0 e azul para classe 1

Fig. 24 Regiões do classificador para rede neural treinada

Machine Translated by Google

Caracterização Teórica de Redes Neurais Profundas 61

Fig. 25 Ricci scaler para dados em espiral

a rede neural está aumentando a distância entre as classes nas regiões limítrofes para poder
discriminar entre as classes.
Podemos usar a observação acima para notar que quaisquer regiões limítrofes com
pequena curvatura podem ser áreas possíveis onde pequenas deformações/transformações
nos dados de entrada podem levar a erros de classificação. Outra observação interessante é
que as redes neurais aprendem a classificar de certas maneiras previsíveis mesmo nas
regiões onde não fornecemos nenhum dado de treinamento.

referências

1. Amodei D, Ananthanarayanan S, Anubhai R, Bai J, Battenberg E, Caso C, Casper J, Catanzaro B, Cheng Q,

Chen G., et al. Fala profunda 2: reconhecimento de fala de ponta a ponta em inglês e mandarim. In:
Conferência Internacional sobre Aprendizado de Máquina, p. 173–182 (2016)
2. Andén, J., Mallat, S.: Espectro de espalhamento profundo. IEEE Trans. Processo de Sinal. 62(16), 4114–
4128 (2014)
3. Bartlett, PL, Maass, W.: dimensão Vapnik-Chervonenkis de redes neurais. In: The Handbook of Brain Theory
and Neural Networks, pp. 1188–1192 (2003)
4. Bengio, Y., Delalleau, O.: Sobre o poder expressivo das arquiteturas profundas. In: International Conference on
Algorithmic Learning Theory, pp. 18-36. Springer, Berlim (2011)
5. Bianchini, M., Scarselli, F.: Sobre a complexidade dos classificadores de redes neurais rasas e profundas.
Em: ESANN (2014)
6. Bredon, GE: Topologia e Geometria, vol. 139. Springer Science & Business Media (2013)
7. Bronstein MM, Bruna J, LeCun Y, Szlam A, Vandergheynst P: Aprendizado profundo geométrico: indo além dos
dados euclidianos. Processo de Sinal IEEE. Mag. 34(4), 18–42 (2017)
8. Bruna, J.: Estabilidade geométrica em domínios euclidianos: a transformada de espalhamento e além.
[Link] (2018)
9. Bruna, J., Mallat, S.: Redes de convolução de espalhamento invariante. IEEE Trans. Padrão Anal.
Mach. Intel. 35(8), 1872–1886 (2013)
Machine Translated by Google

62 P. Kaul e B. Lall

10. Cho K, Van Merriënboer B, Gulcehre C, Bahdanau D, Bougares F, Schwenk H, Bengio Y: Aprendendo
representações de frases usando RNN codificador-decodificador para tradução automática estatística (2014).
arXiv pré -impressão arXiv:1406.1078
11. Choquet-Bruhat, Cécile, Y., DeWitt-Morette, C., Dillard-Bleick, M.: Análise, Variedades e Física. Gulf
Professional Publishing (1982)
12. Cover, TM, Thomas, JA: Elements of Information Theory. Willie (2012)
13. Friedman, J., Hastie, T. e Tibshirani, R.: The Elements of Statistical Learning, vol. 1. Springer
Série em Estatística. Springer, Nova York (2001)
14. Gilmore, R.: Grupos de Mentiras, Álgebras de Mentiras e Algumas de Suas Aplicações. Courier Corp.
(2012)
15. Glorot, X., Bordes, A., Bengio, Y.: Redes neurais retificadoras esparsas profundas. In: Proceedings of the XIV
International Conference on Artificial Intelligence and Statistics, pp. 315–323 (2011)

16. Goodfellow, I., Bengio, Y. e Courville, A.: Deep Learning. Imprensa do MIT (2016)
17. Guss, WH, Salakhutdinov, R.: Sobre a caracterização da capacidade de redes neurais usando alge
topologia cerebral (2018). arXiv pré -impressão arXiv:1802.04443
18. He K, Zhang X, Ren S, Sun J: Aprendizagem residual profunda para reconhecimento de imagem. In
Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 770–778 (2016)
19. Hochreiter S, Schmidhuber J: Longa memória de curto prazo. Computação Neural. 9(8), 1735-1780
(1997)
20. Kaul, P., Lall, B.: Curvatura Riemanniana de redes neurais profundas. IEEE Trans. Rede Neural.
Aprender. Sistema (2019). [Link] 21.
Kearns, MJ, Vazirani, UV, Vazirani, U.: Uma Introdução à Teoria da Aprendizagem Computacional.
Imprensa do MIT (1994)
22. Krizhevsky, A., Sutskever, I., Hinton, GE: Classificação Imagenet com redes neurais convolucionais profundas.
In: Avanços em Sistemas de Processamento de Informação Neural, p. 1097–1105 (2012)

23. LeCun Y, Bengio Y, Hinton G: Aprendizado profundo. Natureza 521 (7553), 436-444 (2015)
24. LeCun, Y., Bottou, L., Bengio, Y., Haffner, P.: Aprendizagem baseada em gradiente aplicada ao documento
reconhecimento. proc. IEEE 86(11), 2278–2324 (1998)
25. LeCun, Y., Cortes, C.: banco de dados de dígitos manuscritos MNIST (2010)
26. Lee, JM: Manifolds Riemannianos: Uma Introdução à Curvatura, vol. 176. Springer, Nova York
(1997)
27. Lee, JM: Introduction to Smooth Manifolds, Vol. 218. Springer, Nova York (2013)
28. Mallat, S.: Espalhamento invariante de grupo. Comum. Puro Aplic. Matemática. 65(10), 1331–1398 (2012)
29. Mallat, S.: Entendendo redes convolucionais profundas. Fil. Trans. R. Soc. A 374 (2065),
20150203 (2016)
30. Matemática. im2col. [Link] Acessado em 10 de fevereiro
2019
31. Monti F, Boscaini D, Masci J, Rodola E, Svoboda J, Bronstein MM: Aprendizado profundo geométrico em
gráficos e variedades usando CNNs de modelo de mistura. In: Anais da CVPR, vol. 1 p. 3 (2017)

32. Munkres, JR: Topologia. Prentice Hall (2000)

33. Nakahara, M.: Geometria, Topologia e Física. Imprensa CRC (2003)
34. Poole B, Lahiri S, Raghu M, Sohl-Dickstein J, Ganguli S: Expressividade exponencial em redes neurais
profundas através do caos transitório. In: Avanços em Sistemas de Processamento de Informação Neural, p.
3360–3368 (2016)
35. Raghu M, Poole B, Kleinberg J, Ganguli S, Sohl-Dickstein J: Levantamento de expressividade em
redes neurais profundas (2016). arXiv pré -impressão arXiv:1611.08083
36. Ren S, He K, Girshick R, Sun J: Faster r-cnn: para detecção de objetos em tempo real com redes de proposta
de região. In: Avanços em Sistemas de Processamento de Informação Neural, p. 91-99 (2015)

37. Saxe, AM, McClelland, JL, Ganguli, S.: Soluções exatas para a dinâmica não linear de aprendizagem em
redes neurais lineares profundas (2013). arXiv pré -impressão arXiv:1312.6120
Machine Translated by Google

Caracterização Teórica de Redes Neurais Profundas 63

38. Schutz, B.: Um Primeiro Curso em Relatividade Geral. Imprensa da Universidade de Cambridge (2009)
39. Sermanet, P., LeCun, Y.: Reconhecimento de sinais de trânsito com redes convolucionais multi-escala. In: Redes
Neurais (IJCNN), p. 2809-2813. IEEE (2011)
40. DI Shuman, SK Narang, P. Frossard, A. Ortega, P. Vandergheynst: O campo emergente de processamento de
sinais em gráficos: estendendo a análise de dados de alta dimensão para redes e outros domínios irregulares.
Processo de Sinal IEEE. Mag. 30(3), 83–98 (2013)
41. C. Szegedy, W. Liu, Y. Jia, P. Sermanet, S. Reed, D. Angelov, D. Erhan, V. Vanhoucke, A. Rabinovich: Indo mais
fundo com convoluções. In: Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition,
pp. 1–9 (2015)
42. Topaz, C., Ziegelmeier, L., Halverson, T.: Análise de dados topológicos de modelos de agregação biológica. PlOS
um. 10. [Link] 43. Vapnik, VN, Chervonenkis, AY: Sobre a convergência
uniforme de frequências relativas de eventos para suas probabilidades. In: Medidas de Complexidade, pp. 11-30.
Springer, Cham (2015)
44. Wiatowski, T., Bölcskei, H.: Uma teoria matemática de redes neurais convolucionais profundas para extração de
recursos (2015). arXiv pré -impressão arXiv:1512.06293 45. Zomorodian A, Carlsson G: Computação de
homologia persistente. Discreto. Computar. Geom. 33(2),
249–274 (2005)
Machine Translated by Google

Análise de dimensionamento do tensor especializado

Arquiteturas de Processamento para Deep
Modelos de Aprendizagem

Yuri Gordienko, Yuriy Kochura, Vlad Taran, Nikita Gordienko,

Alexandr Rokovyi, Oleg Alienin e Sergii Stirenko

Resumo Arquiteturas especializadas de processamento de tensores (TPA) direcionadas para

processamento de redes neurais têm atraído muita atenção nos últimos anos. A complexidade de
computação dos componentes algorítmicos diferentes de algumas redes neurais profundas (DNNs) foi
considerada em relação ao seu uso posterior em tais TPAs. Para demonstrar a diferença crucial entre as
arquiteturas de computação TPU e GPU, a complexidade real de computação de várias DNNs algorítmicas
diferentes foi estimada pela análise de escala proposta de dependências de tempo e aceleração de
treinamento e tempos de inferência como funções de lote e tamanhos de imagem. O destaque principal
foi feito nas DNNs amplamente usadas e algorítmicas diferentes, como VGG16, ResNet50 e CapsNet, na
implementação baseada em nuvem do TPA (atualmente Google Cloud TPUv2). Os resultados do estudo
de desempenho foram demonstrados pelo método de dimensionamento proposto para estimativa do uso
eficiente dessas DNNs nesta infraestrutura.

Os resultados mais importantes e intrigantes são os comportamentos invariantes de escala de

dependências de tempo e aceleração que nos permitem usar o método de escala para prever o

Y. Gordienko (B) Y. Kochura V. Taran N. Gordienko A. Rokovyi O. Alienin S. Stirenko Universidade

Técnica Nacional da Ucrânia “Instituto Politécnico Igor Sikorsky Kyiv”, Kiev, Ucrânia e-mail:
[Link]@gmail. com

Y. Kochura
e-mail: [Link]@[Link]

E-mail
de V. Taran: vladtkv@[Link]

N. Gordienko
e-mail: [Link]@[Link]

A. Rokovyi
e-mail: [Link]@[Link]
O. Alienina
e-mail: [Link]@[Link]
S. Stirenko
e-mail: [Link]@[Link]

© Springer Nature Switzerland AG 2020 65

W. Pedrycz e S.-M. Chen (eds.), Deep Learning: Concepts and
Architectures, Studies in Computational Intelligence 866, https://
[Link]/10.1007/978-3-030-31756-0_3
Machine Translated by Google

66 Y. Gordienko et ai.

executando treinamentos e tempos de inferência sobre os novos TPAs específicos sem informações detalhadas
sobre seus internos mesmo. As dependências de dimensionamento e os poderes de dimensionamento são
diferente para DNNs algoritmicamente diferentes (VGG16, ResNet50, CapsNet) e para
hardwares de computação arquiteturalmente diferentes (GPU e TPU). Esses resultados dão
a estimativa precisa do maior desempenho (taxa de transferência) dos TPAs como o Google
TPUv2 em comparação com GPU para o grande número de cálculos em condições de cálculos de baixo overhead
e alta utilização de unidades TPU por meio do
imagem grande e tamanhos de lote. Em geral, o uso de TPAs como o Google TPUv2 é
quantitativamente provou ser uma ferramenta promissora para aumentar o desempenho da inferência
e até mesmo estágios de treinamento, especialmente em vista da disponibilidade de
TPAs como TCU em Tesla V100 e Titan V fornecidos pela NVIDIA e outros.

Palavras -chave Deep learning Arquitetura de processamento de tensor Processamento de tensor

unidade Tensor core Escalonamento GPU TPUv2 Tempo de treinamento Tempo de inferência _ _ _ _
Aceleração MNIST VGG16 ResNet50 CapsNet _ _ _ _

1. Introdução

O sucesso atual do aprendizado de máquina (ML), especialmente aprendizado profundo (DL) e

redes neurais profundas (DNNs), está fortemente associada ao recente progresso da computação de alto
desempenho (HPC) e arquiteturas de computação especializadas. Permite
usando sua simultaneidade intrínseca e habilidades específicas para melhor eficiência [1-4].
Junto com o crescimento da complexidade do problema de ML/DL, tamanho dos conjuntos de dados e DNNs,
aumenta a quantidade de recursos, classes e categorias de objetos processados. Portanto, as demandas por
maior precisão, aprendizado e inferência mais rápidos também são
intimamente relacionado às demandas por maior poder de computação, maior memória, maior
largura de banda de rede, etc. Para estes fins, várias infra-estruturas de computação são
usado agora: de máquina desktop (com modelo de memória compartilhada) para hardware paralelo
arquiteturas como cluster de computação de alto desempenho (com
modelos de memória) e até sistemas baseados em nuvem (modelo de memória distribuída), que
são especialmente populares e amplamente utilizados agora.
O progresso dessas infraestruturas segue a tendência atual de aceleração de hardware para aplicações DL.
Durante a última década esteve profundamente ligado ao desenvolvimento de unidades de processamento gráfico
(GPU) como processadores de uso geral (GPGPU).
No entanto, recentemente, a grande variedade de plataformas alternativas antigas e novas aparece: de
os bem conhecidos processadores de sinal digital (DSP) e matrizes de portas programáveis em campo
(FPGA) [5, 6] para as novas arquiteturas de circuitos integrados específicos de aplicação (ASIC) [7], incluindo
hardware neuromórfico [8, 9], arquiteturas de processamento de tensor
(TPA) como TCs (Tensor Cores) da NVIDIA [10] e TPUs (unidades de processamento tensor)
pelo Google [11] direcionado para tarefas especializadas de processamento de tensores que são muito usadas
em aplicativos de aprendizado de máquina.
Para uso eficiente dos DNNs complexos modernos nessas infraestruturas de computação, vários aspectos de
ambos devem ser levados em consideração. Eles são especialmente
Machine Translated by Google

Análise de dimensionamento de arquiteturas especializadas de processamento tensor … 67

importante para as novas arquiteturas de computação nos sistemas baseados em nuvem ML/
DL (como Clarifai, Google Cloud Vision, Rekognition, Polly e Lex Amazon, Microsoft Azure
Cognitive Services, IBM Watson, etc.) que se tornam extremamente populares na comunidade
científica e aplicações comerciais. O principal problema das soluções baseadas em nuvem em
comparação com as soluções localizadas é a estimativa adequada dos tempos de treinamento
e inferência que são essenciais para aplicações comerciais.
Neste trabalho, discutimos brevemente alguns TPA especializados, enfatizamos suas
implementações baseadas em nuvem e demonstramos os resultados do estudo de desempenho
para algumas DNNs populares nessa infraestrutura e propomos o método de dimensionamento
para estimar o uso eficiente dessas DNNs nessa infraestrutura.
O principal objetivo deste artigo é investigar o dimensionamento do desempenho de
treinamento e inferência para as GPUs e TPUs disponíveis com um aumento do tamanho do
lote e do tamanho da imagem que permite fazer previsões de tempos de execução e estimar os
overheads ocultos em soluções proprietárias de TPA mesmo.
O restante deste capítulo é organizado da seguinte forma. Na Seção 2 damos um breve
resumo do estado da arte em processamento tensorial e TPAs usados. A seção 3 contém a
descrição da parte experimental relacionada ao hardware selecionado, conjunto de dados,
modelos e métricas utilizadas. A Seção 4 relata os resultados experimentais obtidos, a Seção 5
é dedicada à discussão desses resultados e a Seção 6 resume as lições aprendidas.

2 Antecedentes e Trabalhos Relacionados

Em contraste com as tarefas tradicionais de HPC, as tarefas atuais de ML/DL são resolvidas
principalmente por meio de sistemas acelerados específicos, como GPU e FPGA, apesar de
seu uso para HPC antes. A essência dessas arquiteturas especializadas está em suas
habilidades intrínsecas de usar o alto paralelismo de dados de forma eficiente. Portanto, seu
uso se torna de fato padrão em aplicações ML/DL hoje em dia. Apesar do progresso óbvio,
mesmo os nós de máquina única acelerados por placas de GPU não podem satisfazer as
crescentes demandas de computação de problemas de ML/DL. Como resposta a esses novos
requisitos de maior poder de computação, surgem as seguintes tendências principais:
arquiteturas multi-nó (em sistemas de cluster e nuvem), TPAs especializados e suas
combinações [12].
A demanda adicional pelas novas arquiteturas de computação especializada está relacionada
ao uso de aplicativos ML/DL em vários dispositivos móveis, desde tipos de consumidores (como
smartphones, tablets, eletrônicos vestíveis, etc.) condução, etc). Essa demanda está intimamente
relacionada com os requisitos rigorosos para o menor uso de memória, o número de operações
de computação e o desperdício de energia relacionado [13–15]. Para resolver essas dificuldades,
TPAs especializados como TC [10] e TPU [11] aparecem e são amplamente utilizados agora
em implementações de consumo e industriais.
Machine Translated by Google

68 Y. Gordienko et ai.

As tendências recentes na aceleração de DNNs para dispositivos móveis com TPA podem ser
classificadas em algumas categorias: implementação otimizada, quantização e simplificação
estruturada que convertem uma DNN em uma compacta [16, 17]. Por exemplo,
simplificação estruturada envolve várias abordagens como fatoração tensorial [17],
conexão esparsa [18] e poda de canal [19].
As extensas revisões sobre o processamento eficiente de DNNs geralmente estão relacionadas a
várias perspectivas gerais, modelos, algoritmos de otimização e conjuntos de dados. Outros
considere técnicas de computação para componentes DNN em relação ao paralelismo inerente do
hardware de destino usando algumas técnicas para reduzir a memória geral
usado no hardware de destino [19].
Nesse contexto, a visão estratégica de paralelismo aplicada para DNNs é de grande
importância para avaliação, implementação e extensão de algoritmos e sistemas destinados a suportar
ambientes distribuídos. Recentemente, algumas comparações
foram discutidas medidas sobre as abordagens. Sua simultaneidade e o par-alelismo médio usando o
modelo de trabalho-profundidade foram analisados [12].

2.1 Núcleos Tensores

Tensor Cores (TCs) são aceleradores matemáticos de matriz de hardware propostos na arquitetura
Volta pela NVIDIA. Os Tensor Cores fornecem uma matriz de processamento de matriz 4 × 4 × 4 que
executa a operação D = A*B + C, onde A, B, C e D são matrizes 4 × 4.
TCs em combinação com a biblioteca TensorRT da NVIDIA nos permitem realizar várias
transformando e otimizando operações para gráfico DNN para melhorar o desempenho. Por
Por exemplo, eles incluem a eliminação de camadas com saída não utilizada para evitar
computação, fusão de algumas camadas separadas (convolução, polarização e ativação) em
uma única camada, fusão de camada horizontal, combinando as camadas funcionalmente semelhantes
(com o mesmo tensor de origem e as mesmas operações com parâmetros semelhantes), etc.
O TC e o TensorRT permitem o uso de otimizações de bits baixos. Por exemplo, a aritmética de
meia precisão (também chamada de FP16) reduz o consumo de memória de DNNs e
sobrecargas de leitura e gravação em comparação com a aritmética FP32 ou FP64. Ele permite a
implantação de DNNs maiores e faz isso mais rápido que a aritmética FP32 ou FP64. Está explicado
pelas operações matriciais mais eficientes em TCs, onde a operação D = A*B + C
podem ser implementados pelas entradas A e B que são matrizes FP16, enquanto as matrizes de
acumulação C e D podem ser matrizes FP16 ou FP32. Além disso, TensorRT
usa automaticamente TCs para inferência com aritmética FP16. Como resultado, o TensorRT +
TCs na placa GPU V100 da arquitetura Volta (com aritmética FP16) podem
acelerar o tempo de inferência. Por exemplo, inferência para o modelo ResNet-50 DNN na GPU
V100 + TensorRT + TCs (FP16) é ~4 × mais rápido que a inferência com precisão simples
(FP32) e ~8 × mais rápido que a inferência com precisão dupla (FP64) no mesmo
cartão sem TensorRT + TCs [20].
Mas deve-se notar que esses resultados foram relatados para o lote bastante diferente
tamanhos: 2 para V100 (FP32) e 16 para V100 + TensorRT + TCs (FP16), enquanto nosso
Machine Translated by Google

Análise de dimensionamento de arquiteturas especializadas de processamento tensor … 69

Resultados de benchmark anteriores demonstraram a enorme influência do tamanho do lote no

desempenho de algumas DNNs em arquiteturas de GPU e TPU [21].
Além disso, a arquitetura Turing para TCs não apenas fornece aritmética FP16/FP32 como
a arquitetura Volta para Tensor Cores; eles também adicionam novas aritméticas INT8 e INT4.
O uso da representação de bit inferior na placa GPU Tesla T4 com arquitetura Turing para TCs
fornece uma inferência ~2,5 × mais rápida em comparação com GPU V100 + TensorRT + TCs
(FP16) para o mesmo tamanho de lote 128 [22].

2.2 Unidades de Processamento de Tensores

Recentemente, as Unidades de Processamento de Tensor (TPUs) do Google atraíram atenção

significativa como outro TPA para aumentar a eficiência e a velocidade das DNNs. A TPU
contém 256 × 256 = total de 65.536 unidades lógicas aritméticas (ALUs) que podem processar
65.536 operações de multiplicação e adição para inteiros de 8 bits a cada ciclo. Na medida em
que a TPU roda a 700 MHz, ela pode calcular 65.536 × 7 × 108 = 46 × 1012 operações de
multiplicação e adição ou 92 × 1012 por segundo [11]. De acordo com os benchmarks
anunciados, o TPU pode processar DNNs até 30 × mais rápido e pode ser até 80 × mais
eficiente energeticamente do que CPUs ou GPUs [11]. É possível, porque a TPU é
especificamente adaptada para processar DNNs com mais instruções por ciclo do que CPU e
GPU. Apesar da disponibilidade de alguns testes de desempenho e extensas revisões dos
TPAs disponíveis, como Google TPU versus NVIDIA GPU K80 [11] e Google Cloud TPUv2
versus NVIDIA GPU V100 [23], os estudos sistemáticos sobre seu desempenho em relação ao
dimensionamento (diferentes tamanhos de conjuntos de dados , tamanhos de lote diferentes,
etc.) estão ausentes, exceto para as várias tentativas anteriores [21].
Além disso, o TPU é o TPA exclusivo devido à sua disponibilidade atual como um recurso
de serviço de nuvem apenas nas seguintes configurações: Cloud TPU v2 (180 teraflops, 64 GB
de memória de alta largura de banda (HBM)), Cloud TPU v3 (420 teraflops, 128 GB HBM) ,
Cloud TPU v2 Pod Alpha (11,5 petaflops, 4 TB HBM, rede de malha toroidal 2D) (https://
[Link]/tpu/) [onze].

2.3 Outros Aceleradores de DNNs

Apesar do altíssimo interesse de diversos fabricantes pelos novos TPAs direcionados para
aceleração de DNNs, são em sua maioria soluções proprietárias sem detalhes sobre sua
implementação, com documentação escassa e interfaces de programação de aplicativos
disponíveis. No entanto, eles se tornam partes integrantes de dispositivos de computação como
coprocessadores aceleradores de DNN, sistemas em chips ou ASICs para aplicações
específicas (como visão computacional ou DSP) e as revisões detalhadas com benchmarks
podem ser encontradas em outros lugares [24-28].
Machine Translated by Google

70 Y. Gordienko et ai.

2.4 Algoritmos Paralelos e Arquiteturas de Processamento Tensor

Uma das maneiras de obter o mais alto desempenho na computação de GPU é ocultar a longa latência e
outras sobrecargas computacionais por paralelismo de alto nível de dados para obter uma alta taxa de
transferência, por exemplo, pelos altos valores de tamanho de lote [29, 30].
Normalmente, a amostragem em lote é implementada embaralhando todo o conjunto de dados, e uma
passagem inteira pelo conjunto de dados é chamada de época. Na medida em que um procedimento de
treinamento completo geralmente consiste em dezenas a centenas de tais épocas, a amostragem em lote
com o maior lote possível pode fornecer paralelização e taxa de transferência significativas [31, 32].
Visando a maior precisão, o tamanho ideal do lote representa uma compensação entre o tamanho
mínimo do lote 1 (uma amostra em cada iteração) para o gradiente descendente tradicional, que
comprovadamente converge, e o lote máximo (todo o conjunto de dados em cada iteração), quando a
convergência nem sempre é comprovada sua existência [33].
No entanto, o tamanho ótimo do lote é um problema de otimização complexo, na medida em que é
limitado por requisitos de precisão e eficiência. Mas é empiricamente conhecido que o tamanho do lote não
deve ser muito pequeno, nem muito grande para fornecer convergência e generalização [31, 34-36].

A maioria das operações no aprendizado pode ser modelada como operações em tensores (tipicamente
tensores como um modelo de programação paralela). Tais operações são altamente paralelas aos dados e
apenas os somatórios introduzem dependências. É por isso que a análise quantitativa de TPAs em
condições reais de trabalho pode trazer à tona os detalhes das próprias DNNs e TPAs.

Seguindo o paradigma comumente aceito, uma DNN pode ser representada por um grafcíclico
direcionado (DAG) onde os vértices são os cálculos e as arestas são os fluxos de dados. O paralelismo
computacional em tal grafo pode ser caracterizado por dois parâmetros principais: o volume de trabalho W,
que corresponde ao número total de vértices, e a profundidade D, que é o número de vértices em qualquer
caminho mais longo no DAG. Normalmente esses parâmetros podem caracterizar a complexidade
computacional em um sistema paralelo e obter alguma estimativa prévia para o tempo de execução.

Por exemplo, o tempo de execução em um único processador é ~W, em um número infinito de processos é
~D, e o paralelismo médio ~W/ D [12].
Além dos testes em GPU [37–42], recentemente foi realizada uma análise completa do desempenho
do Google TPU com algumas tentativas de estimar a influência dos hiperparâmetros no desempenho do
TPU também [11, 43]. Além disso, este trabalho visa dar resposta a algumas questões, nomeadamente,
quando pode ser mais eficiente utilizar GPU ou TPU durante as fases de treino e inferência para conjuntos
de dados de vários tamanhos e tamanhos de lote. Na próxima seção é dada uma breve descrição dos
conjuntos de dados usados, rede, equipamentos e métodos de medição.

Isso é especialmente importante tendo em vista o grande interesse para a influência dos hiperparâmetros
de redes neurais profundas (DNN) em seu tempo de execução e desempenho de treinamento [37, 38],
especialmente no que diz respeito ao tamanho do lote, taxa de aprendizado, funções de ativação, etc. . .
[39-42].
No entanto, esses benchmarks não levam em conta a complexidade computacional dos modelos e não
estimam treinamento e inferência em relação aos diferentes
Machine Translated by Google

Análise de dimensionamento de arquiteturas especializadas de processamento tensor … 71

tamanhos de objetos (por exemplo, tamanhos de imagem em problemas de classificação),

tamanho do lote, tamanho do conjunto de dados etc. Por exemplo, para conjuntos de dados
muito grandes, o fornecimento de dados não pode ser fornecido apenas na memória e outras
formas devem ser usadas como geradores de dados para ler dados do disco rígido ou da rede,
incluindo pipelines e outras técnicas. Do ponto de vista prático, essas estimativas são cruciais
para os tempos reais de treinamento e inferência para várias configurações de aplicativos DNN
de produção. Do ponto de vista fundamental, como será mostrado a seguir, os benchmarks de
influência do tamanho do lote e do objeto podem trazer à tona algumas características
específicas dos TPAs e DNNs neles utilizados.

2.5 Algoritmos Paralelos e Complexidade de Computação em DNNs

Abaixo as DNNs que são usadas para aprendizado supervisionado serão consideradas, ou seja,
para otimizar uma DNN em um conjunto de amostras rotuladas (dados de trem) de tal forma
que para a amostra dada (dados de teste) a DNN retornaria um rótulo com alguma probabilidade .
Supõe-se que os dados de trem e de teste são partes diferentes do mesmo conjunto de dados.
Neste trabalho, consideramos um dos tipos de problemas de aprendizado supervisionado, a
tarefa de classificação, onde o objetivo é identificar a qual classe uma amostra provavelmente
pertence, por exemplo, as tarefas de visão computacional. Entre várias DNNs, selecionamos
vários representantes bem conhecidos de redes neurais convolucionais (CNNs) com estruturas
ligeiramente diferentes. Nas CNNs os neurônios são agrupados em camadas de vários tipos
que são descritos abaixo. Na visão computacional, as imagens são usadas como entrada e
representadas como um tensor de 4 dimensões N × C × H × W, onde N é o tamanho do lote (o
número de imagens no lote), H—é a altura da imagem (imagem tamanho), W—é a largura da
imagem (tamanho da imagem), C é o número de cores (canais de cores).
Nas DNNs (na verdade, CNNs) consideradas aqui, o número de recursos característicos
(canais), bem como a largura e a altura de uma imagem, diferem de camada para camada
devido à aplicação de vários operadores a seguir (descritos abaixo) [44, Four . Cinco].
Em uma camada convolucional, uma imagem em forma de tensor 3D x (ou seja, uma fatia
do tensor de lote 4D que representa o lote, ou seja, o conjunto de imagens) é convoluída pelos
operadores de convolução (kernels) Cout de sizeCin × Kh× Kw, onde Cin é a entrada da
camada, Cout é a saída da camada, Kh—é a altura e Kw é a largura do kernel de convolução.
Em termos de complexidade computacional, o trabalho (o número de operações matemáticas)
realizado nesta camada é igual a:

Wconv = O NCoutCin Hi Wi Kx Ky (1)

onde o índice i para Hi e Wi significa o número de camadas porque a altura e a largura da

imagem podem ser alteradas devido a outros operadores, como pooling.
O operador de agrupamento reduz um tensor de entrada pelas dimensões de largura e altura
(e subsequentemente o número de parâmetros treináveis do modelo). O objetivo geral do
pooling é reduzir o tamanho do modelo enquanto enfatiza recursos importantes, porque o
pooling subsequente em todas as camadas convolucionais permite o aprendizado de alto nível.
Machine Translated by Google

72 Y. Gordienko et ai.

características que correspondem a regiões maiores nos dados originais. Do ponto de vista
algorítmico este operador aumenta o trabalho local em cada camada de convolução por
operações Wpool , mas diminui o trabalho global diminuindo Hi e Wi também em cada camada
de convolução, geralmente por lei exponencial. Ele realiza alguma operação em sub-regiões
contíguas de dimensões reduzidas, como cálculo de valor máximo ou médio com a seguinte
complexidade computacional:

Wpool = O(NCin Hi Wi) (dois)

O operador de normalização de lote faz a normalização de imagens no mesmo lote com

média zero e variância de um que permite reduzir o deslocamento de covariáveis e melhorar a
convergência com a seguinte complexidade computacional:

Wbn = O(NCin Hi Wi) (3)

Deve-se notar que vários operadores adicionais, como passada, estofamento e dilatação
podem ser aplicados, o que pode modificar Hi e Wi e influenciar levemente o trabalho, mas
essas peculiaridades estão fora desta consideração.
A camada totalmente conectada é implementada como uma multiplicação matriz-matriz e
adição com a seguinte complexidade de computação:

Wfcn = O (Cout Cin N ) (4)

Normalmente a DNN é representada como alguma composição de função, onde alguns

dos operadores mencionados anteriormente aplicados aos resultados do operador anterior
(composição direta), ou alguns operadores podem reutilizar os resultados do operador anterior
com os valores de saída da camada mais distante em múltiplas camadas subsequentes,
formando conexões de atalho como em redes residuais como ResNet [46] ou redes densas [47].
O número total de cálculos em DNN inclui cálculos de muitas camadas com relacionamentos
complexos e fluxos de trabalho de dados, especialmente levando em consideração os cálculos
complexos para a avaliação direta e retropropagação em diferentes tipos de camada. Às vezes,
o trabalho realizado em cada camada pode dominar assintoticamente e permitir uma estimativa
aproximada de seus custos de computação. Na medida em que as camadas DNN lidam com
tensores de 4 dimensões e muitas operações localizadas dentro delas, elas podem ser
implementadas para execução paralela no nível da camada. Neste contexto, o tempo de
execução de um único operador DNN é difícil de estimar mesmo, apesar de algumas tentativas
de medir o desempenho das implementações de multiplicação de matrizes altamente ajustadas
[48]. Em outros trabalhos o tempo de execução de algumas DNNs foi estimado para lotes de
vários tamanhos com ~5–20% de erro para GPUs [48] e CPUs [49, 50] em ambientes
distribuídos mesmo. Alguns modelos de desempenho para DNNs também foram propostos
para contagens de operação com 10-30% de erro [51], e para estimar os requisitos de
comunicação para os operadores de convolução e pooling [52].
No entanto, em geral, o custo de computação para toda a DNN é difícil de estimar devido à
complexidade intrínseca da maioria das DNNs, especialmente levando em consideração
diferentes arquiteturas de hardware com diferentes paralelismos disponíveis, como TPAs. Mas de
Machine Translated by Google

Análise de dimensionamento de arquiteturas especializadas de processamento tensor … 73

do ponto de vista prático é especialmente importante usar o paralelismo de dados intrínseco em TPAs
aumentando o tamanho do lote e prevendo o impacto do tamanho do lote no tempo de treinamento e
inferência. O fato é que a maioria dos operadores de camada em DNNs são independentes em
relação ao número de amostras (por exemplo, imagens para CNNs) no lote e a forma de paralelização
direta é particionar o trabalho das amostras do lote entre vários recursos computacionais (por exemplo,
exemplo, núcleos e dispositivos de GPU ou núcleos de TPU, chips, pods, dispositivos e hosts).

Várias tentativas foram feitas para verificar a confiabilidade e viabilidade da intuição geral de que
um tamanho de lote maior levará a um melhor desempenho sem perder precisão considerável [31,
35, 36, 53, 54].
Neste trabalho os resultados da estimativa do tempo de treinamento e inferência para várias DNNs
são propostos com base em uma abordagem de escalonamento que permite usar o método de
escalonamento não apenas para previsão de tempo de execução para vários tamanhos de lotes e
objetos, mas também para análise dos overheads ocultos para algumas novas arquiteturas de
computação, especialmente baseadas em soluções proprietárias com uma noção limitada sobre sua
organização interna no exemplo do Google Cloud TPU.

3 Detalhes Experimentais e Computacionais

3.1 Conjuntos de dados, equipamentos, métricas e modelos

Conjuntos de dados: O banco de dados MNIST (banco de dados do Instituto Nacional de Padrões e
Tecnologia Modificado) é um grande banco de dados de dígitos manuscritos (28 × 28 imagens) que
se torna uma referência padrão para sistemas de aprendizado, classificação e visão computacional
[55]. Ele foi derivado de um conjunto de dados maior conhecido como NIST Special Database 19 que
contém dígitos, letras maiúsculas e minúsculas manuscritas. Os subconjuntos desses conjuntos de
dados foram usados com o tamanho de lote máximo possível (para o melhor tempo de execução) a
partir de 8 imagens e até 60.000 imagens.

Equipamento: GPU e TPU. Os recursos de computação GPU e TPU foram usados para investigar a
influência da quantização suportada por hardware no desempenho das DNNs. O NVIDIA Tesla K80
foi usado como placas de GPU durante esses experimentos como recursos de nuvem do Google
Collaborative ([Link] O Google TPUv2 é organizado em módulos de 4
chips com desempenho de 180 TFLOPS, e 64 desses módulos são montados em 256 cápsulas de
chip com 11,5 PFLOPS de desempenho geral. O TPU 2.0 possui um conjunto de instruções otimizado
para executar o Tensorflow e capaz de treinar e executar DNNs. Uma versão de nuvem TPUv2 foi
usada como um hardware de TPU durante esses experimentos, onde 8 núcleos de TPU também
estavam disponíveis como recursos de nuvem do Google Collaborative.

Redes Neurais Profundas: As seguintes DNNs foram utilizadas para esta etapa da pesquisa: VGG16
[56], ResNet50 [46], CapsNet (mostrado na Fig. 1) [57]. A ideia por trás deles era usar os DNNs
conhecidos, mas usá-los para o conjunto de dados MNIST padrão de tamanho e complexidade
moderados para obter resultados por um período razoável.
Machine Translated by Google

74 Y. Gordienko et ai.

Fig. 1 A estrutura da rede neural profunda CapsNet usada no trabalho

O VGG16 consiste em 16 camadas convolucionais e possui uma arquitetura muito uniforme

com apenas 3 × 3 convoluções para todos os filtros. É amplamente descrito e usado na
comunidade ML/DL e atualmente é a escolha preferida para extrair recursos de imagens. A
configuração de peso do VGG16 está disponível publicamente e tem sido usada em muitas
outras aplicações e desafios como um extrator de recursos de linha de base [56].
O ResNet50 tem a maior profundidade e aborda o problema de profundidade treinando uma
interação entre camadas ligeiramente diferente. Em vez de compor camadas como no VGG16,
ele usa resíduos implementados como conexões de identidade “atalho” para a rede. O sistema
então treina as camadas em relação aos seus resíduos em vez de seus valores originais, e isso
resolve a degradação inerente na precisão à medida que as redes se tornam mais profundas.
Com ResNet50 tornou-se possível treinar redes mais profundas com profundidades de até 152
camadas e com maior aumento da qualidade.
Recentemente foi proposta a rede cápsula que é um conjunto aninhado de camadas neurais
que é diferente da CNN usual. Na CNN normal, mais camadas são adicionadas em uma pilha,
mas no CapsNet, mais camadas são adicionadas dentro de uma única camada (ou aninhadas).
Os neurônios dentro de uma cápsula encapsulam as propriedades acima de uma entidade
dentro de uma imagem. Além disso, uma cápsula emite um vetor para representar a existência
da entidade e a orientação do vetor representa as propriedades da entidade. O vetor é enviado
para todos os pais possíveis na rede neural e, para cada pai possível, uma cápsula pode
encontrar um vetor de previsão. O vetor de previsão é calculado com base na multiplicação de
seu próprio peso e uma matriz de peso. Qualquer pai que tenha o maior produto de vetor de
previsão escalar, aumenta a ligação da cápsula. Resto dos pais diminuem
Machine Translated by Google

Análise de dimensionamento de arquiteturas especializadas de processamento tensor … 75

seu vínculo. Esse método de roteamento por acordo é superior ao mecanismo atual, como max-
pooling, porque as rotas de pool máximo são baseadas no recurso mais forte detectado na camada
inferior.

Métricas. Os valores de precisão e perda são calculados para as fases de treinamento, validação e
inferência, em seguida, as curvas de características operacionais do receptor (ROC) são construídas
e a área sob a curva (AUC) é calculada por classe como suas idades médias micro e macro. Para
enfatizar a contribuição da fase de inicialização para GPU e TPU, os seguintes tempos de execução
(para GPU e TPU) por imagem foram calculados para cada execução:

• tempo com overheads = tempo de parede da 1ª iteração/número de imagens; • tempo com

overheads = tempo de parede da 2ª iteração/número de imagens; • tempo sem overheads =
tempo de parede da 2ª iteração/número de imagens.

Os valores de aceleração foram calculados como tempos de execução de GPU divididos por tempos de execução de TPU.

Durante todas as tentativas foram realizadas as seguintes ações. Os valores de precisão e perda
foram calculados para as fases de treinamento, validação e inferência (Fig. 2), então as curvas de
características operacionais do receptor (ROC) foram construídas e a área sob a curva (AUC) foi
calculada por classe como suas médias micro e macro (Fig. 3) . Abaixo alguns exemplos dos
históricos de treinamento e validação são mostrados para GPU K-80 para o conjunto de dados
MNIST (Fig. 2) e os gráficos semelhantes foram obtidos para TPUv2 MNIST (são principalmente os
mesmos e não mostrados aqui devido à ausência de diferença ).

As curvas ROC e os valores AUC (Fig. 3) demonstram a excelente precisão de previsão para 10
épocas mesmo, que foram usadas para comparação com os experimentos semelhantes em TPUv2.

Em seguida, os tempos de treinamento e teste (inferência) foram calculados para diferentes

tamanhos de lote e imagem e plotados como mostrado, por exemplo, na Fig. 4 para GPU K80 e Fig.
5 para TPUv2. Esses resultados demonstram o comportamento de dimensionamento principalmente
diferente dos tempos de treinamento e teste (inferência) para essas duas arquiteturas diferentes.
A diferença drástica da 1ª e 2ª iterações em comparação com a 3ª iteração significa a
disponibilidade dos procedimentos de preparação dos dados iniciais e compilação do modelo (custos
iniciais declarados como “overheads” abaixo). Elas ocorrem durante

Fig. 2 Precisão (esquerda) e perda (direita) durante o treinamento e validação na GPU K80 para VGG16 (para toda a parte de
treinamento do conjunto de dados MNIST 60.000 imagens)
Machine Translated by Google

76 Y. Gordienko et ai.

Fig. 3 Curvas ROC e valores AUC para 10 classes no Google Cloud TPUv2 para ResNet50 (para a parte de teste do
conjunto de dados MNIST — 10.000 imagens)

Fig. 4 Tempos de treinamento (esquerda) e teste (inferência) (direita) versus tamanho do lote na GPU K80 (para toda a
parte de treinamento das imagens do conjunto de dados MNIST 60.000)

Fig. 5 Tempos de treinamento (esquerda) e teste (inferência) (direita) versus tamanho do lote no Google TPUv2 (para toda
a parte de treinamento do conjunto de dados MNIST 60.000 imagens)
Machine Translated by Google

Análise de dimensionamento de arquiteturas especializadas de processamento tensor … 77

a 1ª iteração em hardware de GPU, mas durante a 1ª e 2ª iterações em hardware de TPU e essas

sobrecargas são muito mais longas para hardware de TPU. É por isso que a próxima análise de
dimensionamento foi aplicada a essas “sobrecargas” e as iterações seguintes separadamente.

Em seguida, os valores de aceleração também foram calculados e plotados em função do lote e

tamanho da imagem.
A próxima seção Resultados focará nos tempos de treinamento e inferência e acelerações como
funções do lote e tamanho da imagem, porque os históricos de precisão/perda, curvas ROC e valores
AUC para todos os DNNs usados em GPU-k80 e TPUv2 foram o mesmo nos limites dos erros.

3.2 Complexidade de computação de DNNs

As DNNs utilizadas neste trabalho demonstram o diferente aumento da complexidade computacional

com o aumento do tamanho dos dados de entrada (comprimento do lado da imagem de entrada). O
efeito é explicado pelos diferentes algoritmos implementados neles. O número de parâmetros treináveis
(w) e os correspondentes números teóricos de operações de ponto flutuante (FLOPs) (N) podem ser
calculados manualmente ou por meio das funções de perfil fornecidas no framework Tensorflow [58].

Por exemplo, o número de parâmetros treináveis cresce por diferentes leis para VGG16: w ÿ s1/2
para um modelo com camadas de agrupamento e w ÿ s2 para um modelo sem camadas de
agrupamento (Fig. 6a). O número teórico correspondente de operações de ponto flutuante segue a
mesma dependência: N ÿ s1/2 para VGG16 com camadas de agrupamento e N ÿ s2 para VGG16 sem
camadas de agrupamento (Fig. 6b).
Quanto ao ResNet50 o número de parâmetros não foi alterado na implementação utilizada e o
número correspondente de operações de ponto flutuante foi constante (Fig. 7a). Em contraste no
CapsNet o número de parâmetros treináveis cresce como w ÿ s2 com o crescimento similar do número
correspondente de operações de ponto flutuante (que

Fig. 6 A dependência do número de parâmetros e operações de ponto flutuante na rede neural profunda
VGG16 em função do tamanho quadrado da imagem (comprimento)
Machine Translated by Google

78 Y. Gordienko et ai.

Fig. 7 A dependência do número de parâmetros e operações de ponto flutuante na rede neural

profunda VGG16 em função do tamanho da imagem quadrada (H = W)

é semelhante ao modelo VGG16 sem camadas de agrupamento quando a maior parte dos cálculos é
realizada em camadas convolucionais) (Fig. 7b).
Na medida em que o treinamento e o teste reais incluem várias operações de suporte (como
processamento de dados, formatação e assim por diante), as despesas gerais de cálculo relacionadas aparecem.
Essas sobrecargas podem alterar crucialmente as estimativas dos tempos de parede com base no
número de operações de ponto flutuante, porque às vezes estão relacionadas à organização da
manipulação de dados, que pode ser diferente em vários hardwares, como GPU e TPU. Além disso, eles
podem ser obscurecidos pelos usuários, especialmente em implementações de nuvem (como no TPUv2
fornecido no Google Cloud).
Mas uma comparação das previsões teóricas com os tempos de parede reais como funções do
tamanho dos dados de entrada e do tamanho do lote pode fornecer estimativas reais e fornecer algumas
informações sobre os princípios de funcionamento de alguns hardwares. É por isso que a pesquisa
adicional foi relacionada à execução de vários testes de treinamento e teste no conjunto de dados MNIST
para DNNs já mencionados, como VGG16, ResNet50 e CapsNet em arquiteturas de GPU e TPU. O
objetivo principal foi fazer uma análise comparativa de GPU e TPU com base na dependência do tempo
e aceleração versus diferentes tamanhos de dados de entrada e tamanhos de lote. Para isso, foi utilizada
a análise de escala que está descrita na próxima seção.

3.3 Análise de Escala

Para demonstrar a principal diferença entre essas arquiteturas de computação (TPU e GPU), a
complexidade real de computação para várias DNNs algorítmicas diferentes foi estimada pela análise de
escala. A técnica de escalonamento é amplamente utilizada em vários campos da ciência [59, 60],
incluindo finanças [61], ciência da computação e redes [62], biologia [63], física [64], ciência dos materiais
[65], geologia [66 ], processos de agregação [67, 68], etc.

A ideia por trás da técnica de escalonamento é a suposição de que o comportamento invariante de

escala de algumas funções caracteriza o processo no que diz respeito à mudança de
Machine Translated by Google

Análise de dimensionamento de arquiteturas especializadas de processamento tensor … 79

Tabela 1 As potências nas leis de escala para os números de parâmetros treináveis (ÿ) e os valores teóricos
números de operações de ponto flutuante (ÿ) para vários modelos DNN
Modelo ÿ (parâmetros) ÿ (FLOPs)
VGG16 0,50±0,05 0,50±0,05

VGG16 (não MaxPool) 1,99 ± 0,01 1,99 ± 0,01

ResNet50 0,00±0,00 0,00±0,00

CapsNet 2,07 ± 0,02 2,11 ± 0,02

as outras características. Assume-se a renormalização adequada (escalonamento) do

funções nos permitem encontrar a semelhança geral para as funções que caracterizam o
processo sob diferentes valores de parâmetro de escala.
Assumindo que temos alguma função f (x,...) e trocamos seu argumento x por
o fator de escala k muda por kÿ vezes significa

f (kx,...) = kÿ f (x,...) (5)

que é típico para funções homogêneas. Por essas mudanças de vários parâmetros
para diferentes sistemas (por exemplo, diferentes arquiteturas de hardware desconhecidas) um
pode encontrar os argumentos para os quais essa função pode ser dimensionada com insights sobre o
razões para esta escala.
Retornando à seção anterior os números de parâmetros treináveis para todos
redes demonstram as seguintes leis de escala semelhantes:

w = f (s,...) = sÿ fsc (6)

N = g(s,...) = sÿgsc , (7)

onde ÿ e ÿ são dados na Tabela 1, fsc e gsc são versões em escala de f e g

funções.

4 Resultados

4.1 Vgg16

Para caracterizar o tempo de execução, será utilizada a seguinte notação (para VGG16
aqui e todos os outros DNNs abaixo):

tregime = fregime(s, b,it), (8)

Machine Translated by Google

80 Y. Gordienko et ai.

onde
tregime—o tempo de execução da parede em um dos dois regimes: regime de treinamento
(regime = treinar) e teste ou inferência (regime = inf );
Dd—os testes em execução, onde D é um dos dois dispositivos: GPU K-80 (D = G) e
TPUv2 (D = T), e d é o número de iteração em execução: 1 para 1ª, 2 para 2ª, 3 para d > 2; s—o
tamanho da imagem (o comprimento lateral das imagens quadradas H = W do conjunto de dados
MNIST
dimensionado de 28 × 28 a 96 × 96 pixels);
b—o tamanho do mini-lote (lote) de 8 ao número máximo possível de imagens em um lote.

Por exemplo, tinf = finf(s, b, T1) significa o tempo de inferência como uma imagem de função
size se tamanho do lote b para a 1ª iteração no dispositivo TPUv2.
As imagens superiores (Fig. 8a, b) representam a primeira e a segunda iterações para GPU
K80 (G1 e G2) e TPU (T1 e T2) onde foram observadas sobrecargas significativas, e as imagens
inferiores (Fig. 8c, d) representam as terceira iteração com despesas gerais muito menores.

Treinamento testando

(a) ttrain(s, Dd) para Dd ÿ [G1, G2, T1, T2] (b) tinf(s, Dd) para Dd ÿ [G1, G2, T1, T2]

(c) ttrain(s, Dd) para Dd ÿ [G3, T3] (d) tinf(s, Dd) para Dd ÿ [G3, T3]

Fig. 8 Tempo (por imagem) versus tamanho da imagem para regimes de treinamento (esquerda) e teste
(inferência) (direita) para VGG16. Cada curva corresponde ao tamanho do lote e iteração indicados na legenda
Machine Translated by Google

Análise de dimensionamento de arquiteturas especializadas de processamento tensor … 81

O seguinte comportamento estável e diferente pode ser observado para GPU e

Arquiteturas de TPU:

• TPU causa sobrecargas muito maiores (Fig. 8a, b) para os regimes de treinamento e teste (inferência)
para as iterações 1ª (T1) e 2ª (T2) em comparação com as iterações 1ª (G1) e 2ª (G2)
correspondentes na GPU. Essa diferença é especialmente alta para o tempo de latência na 1ª
iteração.
• TPU demonstra os overheads muito maiores para a 1ª iteração e 2ª iterações em comparação com
as iterações posteriores (Fig. 8c, d) (que têm os mesmos tempos de execução nos limites do desvio
padrão), mas a GPU demonstra os overheads muito maiores apenas para a 1ª iteração.

• A TPU causa grandes sobrecargas para os regimes de treinamento e teste (inferência) na 1ª (T1) e
2ª (T2) iterações em comparação com a 3ª (T3) iteração e em comparação com todas as iterações
na GPU. • Para as iterações posteriores à 2ª (Fig. 8c, d), a TPU demonstra tempos de execução
muito menores em comparação com a GPU. • Todas as curvas tempo versus tamanho da imagem para
cada regime tregime = fregime(s, b,it) são visualmente semelhantes e por isso a hipótese de que
são funções homogêneas é proposta e será verificada na próxima seção abaixo.

Dimensionamento para dependências

de tempo Na medida em que o intervalo de tamanhos de lote era muito maior do que o intervalo de
tamanhos de imagem, a análise de dimensionamento foi realizada com base nas curvas de tempo de
execução versus tamanho do lote. As dependências do tempo de execução versus tamanho do lote
foram plotadas (Figs. 9a, b e 10a, b) com a semelhança visual muito pronunciada das curvas para cada regime.
Para fazer a análise de dimensionamento, o seguinte procedimento de dimensionamento foi aplicado:

SC fregime(si, b,it) =
regime(si, b) = fregime smin, b,it bÿ f sÿ
vocês

regime(o(si), o(b),it) i
SC

= = sÿ
SC Ei Regime Fsc (si, b),
sÿ minbÿ f regime o smin , o(b),it f
SC
regime(o(si), o(b),it)
onde Fsc regime(si, b) = sÿÿ (9)
SC
regime min f o smin , o(b),it

Assumindo a baixa correlação entre sÿ e regime Fsc(si, b), ou seja, se o regime Fsc(si, b) = 0, após
Ei

covariância entre eles Cov sÿ eu , a média de cada regime de curva (si, b) sobre b pode-se
SC
obter:
vocês

sc
t = sÿ
regime(si, b) b Ei Regime Fsc(si, b) =
=sÿ
Ei Regime Fsc(si, b) b + Cov sÿ Ei
,
Regime Fsc(si, b) ÿ sÿ Ei
Ei,

= const. b (10)
onde Ci = regime Fsc(si, b)
Machine Translated by Google

82 Y. Gordienko et ai.

Treinamento testando

(a) treinar (b) vs. b (b) estanho (b) vs. b

(c) t sb( vs.

SC
) , Sim
Comboio
b Ei
(d) tsb
inf ()
SC
vs., Sim
Ei
b

(e) F sb (
SC
), vs. b SC
F inf
sbi( vs. b
) , (f)
Comboio Ei

Fig. 9 Tempo por imagem para regimes de treinamento (esquerda) e teste (direita) para a 1ª e 2ª iterações
com grandes despesas gerais, ou seja, para Dd ÿ [G1, G2, T1, T2] para VGG16

Então a potência ÿ pode ser determinada após a plotagem log-log dos valores médios
SC
regime(si, b) b em função de si para cada curva das Figs. 9a, b e 10a, b e
vocês

ajustando os dados pela linha direta:

Machine Translated by Google

Análise de dimensionamento de arquiteturas especializadas de processamento tensor … 83

Treinamento testando

(a) treinar (b) vs. b (b) estanho (b) vs. b

(c) sb ( , )
SC

Comboio
vs. Sim (d) sbSC

inf (
, ) vs. Sim
Ei
b Ei
b

SC
SC
(e) F sb ( ) ,
Comboio Ei
vs. b
(f) Finfsbi
( ), vs. b

Fig. 10 Tempo por imagem para regimes de treinamento (esquerda) e teste (direita) para 3ª iteração (sem
despesas gerais) para VGG16

SC
log t ÿlog(Ci)
regime(si, b) b
ÿ= (onze)
log(sim)

Os resultados de tal ajuste são mostrados para o regime de treinamento nas Figs. 9c e 10c, e
para o regime de teste nas Figs. 9d e 10d. Se as suposições acima forem verdadeiras,
SC
então todos os pontos t como uma função ofsi no gráfico log-log deve se alinhar ao longo do
regime(si, b) b
Machine Translated by Google

84 Y. Gordienko et ai.

linha direta (Figs. 9c, d e 10c, d). Além disso, se as premissas acima forem

true, então todos os pontos para as funções Fsc regime(si, b) que são realmente versões reescalonadas
de você
SC
regime(si, b) pela divisão de si na potência ÿ determinada pelo ajuste deve entrar em colapso
para cada regime (Figs. 9e, f e 10e, f).

vocês
SC
regime(si, b)
Regime Fsc(si, b) = (12)
sÿ
Ei

Finalmente, ambas as condições são verdadeiras, ou seja, os pontos são alinhados ao longo de retas
linha (Figs. 9c, d e 10c, d) e as curvas de regime colapsam (Figs. 9e, f e 10e, f), que
confirmam as suposições anteriores e apoiam a ideia sobre a dependência de escala:

tregime(s) ÿ sÿr

onde ÿr é a característica de potência para o regime específico.

Dimensionamento para dependências de aceleração

O mesmo procedimento de dimensionamento pode ser aplicado à dependência do speedup versus imagem
tamanho e tamanho do lote para testes de treinamento e teste em TPU em comparação com o mesmo
testes na GPU:

s ÿGd,r bÿGd, rf SC
o smin , o(b),it
tGd,r(se, b) = Ei D'us, r =
ssc
r
(si, b) = tT
d,r(si, b) s ÿTd ,r bÿT d,r f SC
Ei T d,r(o(se), o(b),it)

ÿGd,rÿÿT d,r Fsc Gd,r(se, b)

= sim bÿGd,rÿÿT d,r = sim ÿSd,r (13)
Ei Ei
bÿSd,r Ssc Sd,r(se, b),
fscT d,r(se, b)

Onde

ÿSd,r = ÿGd,r ÿ ÿT d,r

(14)

(quinze)
ÿSd,r = ÿGd,r ÿ ÿT d,r

Fsc Gd,r(se, b)
. (16)
Ssc Sd,r(se, b) =
fscT d,r(se, b)

Os valores da potência ÿDd,r para VGG16 estão resumidos na Tabela 2.

Tabela 2 O tamanho da imagem potencializa ÿDd,r nas leis de escala para o tempo de execução do VGG16

Tempo ÿT d,r, TPU ÿGd,r, GPU

T1 T2 T3 G1 G2 G3

testando ÿ0,05 ± 0,02 0,02 ± 0,01 ÿ0,87 ± 0,02 ÿ1,00 ± 0,10 ÿ1,19 ± 0,1 ÿ1,11 ± 0,09

Treinamento ÿ0,03 ± 0,02 ÿ0,64 ± 0,02 ÿ0,62 ± 0,03 ÿ0,14 ± 0,12 ÿ1,14 ± 0,05 ÿ1,14 ± 0,05
Machine Translated by Google

Análise de dimensionamento de arquiteturas especializadas de processamento tensor … 85

Tabela 3 Os poderes do tamanho da imagem nas leis de escala para o speedup: ÿ F

Sd,r—ajustado dos gráficos em

speedup e ÿpr Sd,r—previsto a partir das leis de escala no tempo de execução para VGG16

ÿpr F
ÿ ajustado a partir de gráficos de aceleração
Sd,r =ÿGd,r ÿ ÿT d,r previsto a partir do tempo Sd,r
escalar
S1 S2 S3 S1 S2 S3

testando ÿ0,95 ± 0,10 ÿ1,21 ± 0,09 ÿ0,24 ± 0,09 ÿ0,91 ± 0,11 ÿ1,15 ± 0,08 ÿ0,40 ± 0,07

Treinamento ÿ0,11 ± 0,12 ÿ0,50 ± 0,05 ÿ0,52 ± 0,05 ÿ0,29 ± 0,13 ÿ0,70 ± 0,13 ÿ0,78 ± 0,08

Os valores da potência ÿSd,r para VGG16 podem ser obtidos por análises de escala para
tempo e speedup e comparados na Tabela 3.
As potências de tamanho de lote (ÿ) nas leis de escala para o speedup podem ser calculadas diretamente
de suas parcelas (Figs. 11a e 12a, b), exceto para o regime de teste com sobrecarga
(Fig. 12b) (Tabelas 4).

4.2 ResNet50

As imagens superiores (Fig. 13a, b) representam a primeira e a segunda iteração para GPU-K80
(G1 e G2) e TPU (T1 e T2) onde foram observadas sobrecargas significativas,
e as imagens inferiores (Fig. 13c, d) representam a terceira iteração com muito menor
despesas gerais (Fig. 14).
Os valores da potência ÿ para ResNet50 estão resumidos na Tabela 5.
Assim como no caso da rede VGG16, os poderes do tamanho do lote (ÿ) no dimensionamento
leis para a aceleração podem ser calculadas diretamente de seus gráficos (não mostrado aqui para
brevidade), exceto para o regime de testes com overheads (Tabelas 6 e 7).

4.3 CapsNet

Novamente, as imagens superiores (Fig. 16a, b) representam a primeira e a segunda iterações para GPU
K80 (G1 e G2) e TPU (T1 e T2) onde foram observadas sobrecargas significativas,
e as imagens inferiores (Fig. 16c, d) representam a terceira iteração com muito menor
despesas gerais (Fig. 17).
Os valores da potência ÿ para CapsNet estão resumidos na Tabela 8.
Novamente, as potências de tamanho de lote (ÿ) nas leis de escala para o aumento de velocidade podem ser calculadas

diretamente de suas parcelas (não mostradas aqui para brevidade), exceto para o regime de teste
com despesas gerais (Tabelas 9 e 10).
Machine Translated by Google

86 Y. Gordienko et ai.

Treinamento testando

(a) Deformação (b) vs. b (b) Sinf(b) vs. b

(c) S sb( vs.

SC
) , Sim
Comboio
b Ei
SC
(d) S inf
sb( )vs. Sim
eu ,
b

SC
(e) S sb vs.
( )b,
Comboio Ei
(F) Sinf
sb( vs. b
SC

Ei
),
Fig. 11 Aceleração para regimes de treinamento (esquerda) e teste (direita) para a 1ª e 2ª iterações com
grandes despesas gerais, ou seja, para Dd ÿ [G1, G2, T1, T2] para VGG16
Machine Translated by Google

Análise de dimensionamento de arquiteturas especializadas de processamento tensor … 87

Treinamento testando

(a) Deformação (b) vs. b (b) Sinf(b) vs. b

(c) s sb ( ) ,
SC

Comboio
vs. Sim (d)
SC
sb( ) ,
s inf vs. Sim
Ei
b Ei
b

SC
(e)
SC
s sb ( ) , vs. b
Comboio Ei
(F) s inf
sb( Ei ), vs. b

Fig. 12 Aceleração para regimes de treinamento (esquerda) e teste (direita) para 3ª iteração (sem sobrecargas)
para VGG16

Tabela 4 O tamanho do lote

acelerar ÿSd,r, ajustado a partir de gráficos de aceleração
potências (ÿ) em leis de escala para
S1 S2 S3
a aceleração para VGG16
testando 0,10±0,04 0,07 ± 0,06 0,23 ± 0,02

Treinamento 0,16±0,02 0,43 ± 0,01 0,44 ± 0,01

Machine Translated by Google

88 Y. Gordienko et ai.

Tabela 5 O tamanho da imagem potencializa ÿDd,r nas leis de escala para o tempo de execução do ResNet50

Tempo ÿT d,r, TPU ÿGd,r, GPU

T1 T2 T2 G1 G2 G3

testando ÿ0,33 ± 0,04 ÿ0,36 ± 0,07 ÿ0,59 ± 0,07 ÿ0,47 ± 0,11 ÿ1,08 ± 0,05 ÿ1,19 ± 0,05

Treinamento ÿ0,04 ± 0,30 ÿ0,24 ± 0,01 ÿ0,25 ± 0,02 0,03 ± 0,02 ÿ0,94 ± 0,05 ÿ0,97 ± 0,04

Tabela 6 Os poderes do tamanho da imagem nas leis de escala para o speedup: ÿ F

Sd,r—ajustado dos gráficos em

speedup e ÿpr Sd,r—previsto a partir das leis de escala no tempo de execução para ResNet50

ÿpr F
ÿ
= ÿGd,r ÿ ÿT d,r previsto a partir do tempo Sd,r ajustado a partir de gráficos de aceleração

Escala Sd,r
S1 S2 S3 S1 S2 S3

testando ÿ0,14 ± 0,11 ÿ0,72 ± 0,07 ÿ0,6 ± 0,07 ÿ0,38 ± 0,50 ÿ1,31 ± 0,75 ÿ0,76 ± 0,11

Treinamento 0,07 ± 0,30 ÿ0,7 ± 0,05 ÿ0,72 ± 0,04 0,21 ± 0,08 ÿ0,85 ± 0,04 ÿ0,91 ± 0,04

(uma)
Treinamento
(b) testando

(c) (d)

Fig. 13 Tempo (por imagem) versus tamanho da imagem para regimes de treinamento (esquerda) e teste (inferência) (direita)
para ResNet50. Cada curva corresponde ao tamanho do lote e iteração indicados na legenda
Machine Translated by Google

Análise de dimensionamento de arquiteturas especializadas de processamento tensor … 89

Treinamento testando

(a) treinar (b) vs. b (b) tinf(b) vs. b

(c) t sb( ) ,
SC

Comboio Ei
b
vs. Sim (d)
SC

inf ( ) t sb
Ei
, b
vs. Sim

SC
SC
(e) F sb ( ) ,
Comboio Ei
vs. b
(f) Finfsbi
( ), vs. b

Fig. 14 Tempo por imagem para regimes de treinamento (esquerda) e teste (direita) para 3ª iteração (sem
despesas gerais) para ResNet50
Machine Translated by Google

90 Y. Gordienko et ai.

Treinamento testando

(a) Deformação (b) vs. b (b) Sinf(b) vs. b

(c) s sb ( ) ,
SC

Comboio
vs. Sim (d)
SC
s inf
sb( ) vs. Sim
Ei
b eu ,
b

SC

(e)
SC
s sb ( ) ,
Comboio Ei
vs. b (F) s inf
sb( Ei ), vs. b

Fig. 15 Aceleração para regimes de treinamento (esquerda) e teste (direita) para 3ª iteração (sem sobrecargas)
para ResNet50

Tabela 7 O tamanho do lote

acelerar ÿSd,r, ajustado a partir de gráficos de aceleração
potências (ÿ) em leis de escala para
S1 S2 S3
a aceleração para ResNet50
testando 0,35±0,09 0,71 ± 0,12 0,48 ± 0,02

Treinamento 0,36 ± 0,18 0,63 ± 0,03 0,65 ± 0,03

Machine Translated by Google

Análise de dimensionamento de arquiteturas especializadas de processamento tensor … 91

(uma)
Treinamento
(b) testando

(c) (d)

Fig. 16 Tempo (por imagem) versus tamanho da imagem para regimes de treinamento (esquerda) e teste (inferência) (direita)
para CapsNet. Cada curva corresponde ao tamanho do lote e iteração indicados na legenda

5 discussões

Os valores significativos de speedup para uso de TPU em comparação com GPU foram obtidos
para modelos bastante algoritmicamente diferentes para as iterações posteriores (> 2ª) quando o
as despesas gerais iniciais não têm impacto:

• VGG16 - até 10 × para regime de treinamento (Fig. 12a) e até 10 × para teste
regime (Fig. 12b),
• ResNet50 - até 6 × para regime de treinamento (Fig. 15a) e até 30 × para teste
regime (Fig. 15b),
• CapsNet - até 2 × para regime de treinamento (Fig. 18a) e até 4 × para regime de teste
(Fig. 18b).

Esses valores foram alcançados mesmo para uso em escala extremamente baixa do Google TPUv2
unidades (8 núcleos apenas) em comparação com a unidade GPU bastante poderosa (NVIDIA Tesla
K80). Mas a diferença crucial entre as arquiteturas GPU e TPU é o radicalmente
diferentes valores de tempo de latência para preparação de dados específicos e compilação de software
(muito maior para TPU) antes da 1ª e 2ª iterações. Essa diferença a favor
de GPU e é por isso que nenhuma aceleração > 1 foi observada para todos os modelos no 1º e
2ª iterações (Fig. 11).
Machine Translated by Google

92 Y. Gordienko et ai.

Treinamento testando

(a) treinar (b) vs. b (b) tinf(b) vs. b

(c) sb ( ) ,
SC

Comboio
vs. Sim (d) sb
SC

inf (
, ) vs. Sim
Ei
b Ei
b

SC
SC
F sb ( ) , vs. b vs. b
(e) Comboio Ei
(f) Finfsbi
( ),

Fig. 17 Tempo por imagem para regimes de treinamento (esquerda) e teste (direita) para 3ª iteração (sem
despesas gerais) para CapsNet

Tabela 8 O tamanho da imagem potencializa ÿDd,r nas leis de escala para o tempo de execução do CapsNet

Tempo ÿT d,r, TPU ÿGd,r, GPU

T1 T2 T3 G1 G2 G3

testando ÿ2,21 ± 0,07 ÿ2,78 ± 0,10 ÿ2,78 ± 0,10 ÿ2,30 ± 0,21 ÿ2,92 ± 0,06 ÿ2,92 ± 0,07

Treinamento ÿ2,08 ± 0,03 ÿ2,74 ± 0,06 ÿ2,74 ± 0,07 ÿ1,78 ± 0,14 ÿ2,95 ± 0,17 ÿ2,96 ± 0,17
Machine Translated by Google

Análise de dimensionamento de arquiteturas especializadas de processamento tensor … 93

Tabela 9 Os poderes do tamanho da imagem nas leis de escala para o speedup: ÿ F

Sd,r—ajustado dos gráficos em

speedup e ÿpr Sd,r—previsto a partir das leis de escala no tempo de execução para CapsNet

ÿpr ÿ
F
= ÿGd,r ÿ ÿT d,r previsto a partir do tempo Sd,r ajustado a partir de gráficos de aceleração

Escala Sd,r
S1 S2 S3 S1 S2 S3

testando ÿ0,09 ± 0,21 ÿ0,14 ± 0,10 ÿ0,14 ± 0,10 ÿ0,56 ± 0,13 ÿ0,42 ± 0,80 ÿ0,42 ± 0,08

Treinamento 0,3 ± 0,14 ÿ0,21 ± 0,17 ÿ0,22 ± 0,17 ÿ0,36 ± 0,15 ÿ0,42 ± 0,10 ÿ0,44 ± 0,10

Tabela 10 O tamanho do lote

acelerar ÿSd,r, ajustado a partir de gráficos de aceleração
potências (ÿ) em leis de escala para
S1 S2 S3
o aumento de velocidade para CapsNet
testando 0,18 ± 0,05 0,07 ± 0,02 0,07 ± 0,02

Treinamento 0,07 ± 0,03 0,03 ± 0,02 0,05 ± 0,02

Os valores de aceleração dependem do nível de utilização das unidades TPUv2 e aumentam

start (ou seja, a aceleração se torna > 1) para diferentes valores de lote e tamanhos de imagem por bastante
modelos algoritmicamente diferentes para as iterações posteriores (> 2ª) quando o
despesas gerais não têm impacto:

• VGG16—para todos os tamanhos de lote e imagem, exceto para o menor tamanho de imagem e
tamanho do lote <10 no regime de treinamento (Fig. 12a),
• ResNet50—para todos os tamanhos de lote e imagem em regime de teste e para os vários
tamanho do lote no regime de treinamento, por exemplo, para b > 102 para o menor tamanho de imagem
(Fig. 15a),
• CapsNet — para todos os tamanhos de lote e imagem, exceto para o menor tamanho de imagem (s =
24) em regime de treinamento (Fig. 18a).

Esses resultados demonstram que o uso de TPAs como Google TPUv2 é mais eficaz
(mais rápido) do que GPU para o grande número de cálculos sob condições de baixa
Cálculos de despesas gerais e alta utilização de unidades TPU. Além disso, esses resultados
foram obtidos para várias DNNs algorítmicas diferentes sem prejuízo da
precisão e perda que foram iguais para GPU e TPU até o 3º significativo
dígito para o conjunto de dados MNIST, e confirmar os resultados semelhantes obtidos anteriormente [21]. Mas
é de salientar que estes resultados foram obtidos sem prejuízo da precisão
e perda para o conjunto de dados MNIST relativamente simples e baixo número de classes (=10).
As investigações atuais do impacto do lote, imagem e tamanho da rede ainda estão sob
trabalhar agora e seus resultados serão publicados em outro lugar [69].
Os resultados mais importantes e intrigantes são os comportamentos invariantes de escala de
dependências de tempo e aceleração que nos permitem usar esse método de dimensionamento para prever
os tempos de execução nas novas arquiteturas específicas sem informações detalhadas
sobre seus internos mesmo. As dependências de dimensionamento e os poderes de dimensionamento são diferentes
para DNNs algoritmicamente diferentes (VGG16, ResNet50, CapsNet) e para hardware de computação
arquiteturalmente diferente (GPU e TPU).
Machine Translated by Google

94 Y. Gordienko et ai.

Treinamento testando

(a) Deformação (b) vs. b (b) Sinf(b) vs. b

(c) s sb ( ) ,
SC

Comboio
vs. Sim (d)
SC
s inf
sb( ) vs. Sim
Ei
b eu ,
b

SC
(e)
SC
s sb ( ) , vs. b (F) s inf
sb( Ei ), vs. b
Comboio Ei

Fig. 18 Aceleração para regimes de treinamento (esquerda) e teste (direita) para 3ª iteração (sem sobrecargas)
para CapsNet

A diferença crucial da 1ª e 2ª iterações em comparação com a 3ª

iteração significa a disponibilidade da preparação de dados inicial e compilação do modelo
procedimentos (despesas gerais iniciais indicadas como "despesas gerais" abaixo). Elas ocorrem durante
a 1ª iteração no hardware da GPU, mas durante a 1ª e 2ª iterações no TPU
hardware e essas despesas gerais são muito maiores para hardware TPU. A complexidade
das dependências de aceleração escalada para iterações iniciais (1ª e 2ª) e seus relativos
simplicidade para as iterações tardias (> 2ª) refletem a sensibilidade das DNNs ao inicial
Machine Translated by Google

Análise de dimensionamento de arquiteturas especializadas de processamento tensor … 95

estágios de diferentes hardwares de computação. Essa complexidade está relacionada com os

detalhes complexos e ocultos (em hardware TPUv2 proprietário) da preparação de dados e
compilação de DNN para TPA. As razões para essa complexidade e sensibilidade de DNNs para
TPA devem ser o tópico de futuras investigações aprofundadas.
Além da arquitetura Google TPU, as ferramentas específicas de hardware de processamento
tensor estão disponíveis em outras placas GPU modernas como Tesla V100 e Titan V da NVIDIA
baseadas na microarquitetura Volta com Tensor Cores Units especializadas (640 TCU) e sua
influência no treinamento e aceleração de inferência estão sob investigação e serão relatados em
outro lugar [69].
Na medida em que o tamanho do modelo limita o espaço de memória disponível para o lote
máximo possível de imagens, outras técnicas podem ser úteis para diminuir o tamanho do
modelo, como quantização e poda [70-72], e investigação do aumento do tamanho do lote no
desempenho . Esses resultados podem ser usados para otimizar parâmetros de várias aplicações
ML/DL onde um grande lote de dados deve ser processado, por exemplo, em sistemas avançados
de assistência ao motorista (ADAS), onde arquiteturas especializadas do tipo TPA podem ser
usadas [73].

6. conclusões

Neste trabalho é feita uma breve revisão para algumas arquiteturas especializadas de
processamento de tensores (TPA) atualmente disponíveis direcionadas ao processamento de
redes neurais. A complexidade de computação dos componentes algorítmicos diferentes de
algumas redes neurais profundas (DNNs) foi considerada em relação ao seu uso posterior em tais TPAs.
Para demonstrar a diferença crucial entre as arquiteturas de computação TPU e GPU, a
complexidade real de computação de várias DNNs algorítmicas diferentes foi estimada pela
análise de escala proposta de dependências de tempo e aceleração de treinamento e tempos de
inferência como funções de lotes e tamanhos de imagem.
O destaque principal foi feito nas DNNs amplamente usadas e algorítmicas diferentes, como
VGG16, ResNet50 e CapsNet, na implementação baseada em nuvem do TPA (atualmente
Google Cloud TPUv2). Os resultados do estudo de desempenho foram demonstrados pelo
método de dimensionamento proposto para estimativa do uso eficiente dessas DNNs nesta
infraestrutura.
Os resultados mais importantes e intrigantes são os comportamentos invariantes de escala de
dependências de tempo e aceleração que nos permitem usar o método de escala para prever os
tempos de treinamento de corrida e inferência nos novos TPAs específicos sem informações
detalhadas sobre seus internos mesmo. As dependências de dimensionamento e os poderes de
dimensionamento são diferentes para DNNs algoritmicamente diferentes (VGG16, ResNet50,
CapsNet) e para hardware de computação arquiteturalmente diferente (GPU e TPU).
Esses resultados fornecem a estimativa precisa do maior desempenho (taxa de transferência)
de TPAs como Google TPUv2 em comparação com GPU para o grande número de cálculos em
condições de cálculos de baixo overhead e alta utilização de unidades de TPU por meio da
imagem grande e lote tamanhos.
Machine Translated by Google

96 Y. Gordienko et ai.

Em geral, o uso de TPAs como o Google TPUv2 é quantitativamente comprovado como uma
ferramenta muito promissora para aumentar o desempenho das etapas de inferência e
treinamento mesmo, principalmente na visão de disponibilidade de TPAs específicos semelhantes
como TCU no Tesla V100 e Titan V fornecido pela NVIDIA e outros.

referências

1. LeCun, Y., Bengio, Y., Hinton, G.: Aprendizagem profunda. Natureza 521 (7553), 436-444 (2015)
2. Schmidhuber, J.: Aprendizado profundo em redes neurais: Uma visão geral. Rede Neural. 61, 85-117
(2015)
3. Wang, H., Raj, B.: Sobre a origem do aprendizado profundo. arXiv pré -impressão arXiv:1702.07800 (2017)
4. Bengio, Y.: Aprendizagem profunda das representações: olhando para o futuro. In: International Conference on
Statistical Language and Speech Processing, pp. 1-37. Springer, Berlim, Heidelberg (2013)
5. Lacey, G., Taylor, GW, Areibi, S.: Deep Learning em FPGAs: Passado, Presente e Futuro. arXiv
pré -impressão arXiv:1602.04283 (2016)
6. Nurvitadhi, E. et al.: As FPGAs podem superar as GPUs na aceleração de redes neurais profundas de próxima
geração? In: Proceedings ACM/SIGDA International Symposium on Field-Programmable Gate Arrays (FPGA
'17), pp. 5–14 (2017)
7. Chen T, Du Z, Sun N, Wang J, Wu C, Chen Y, Temam O: DianNao: um acelerador de alto rendimento de
pequena pegada para aprendizado de máquina onipresente. In: Proceedings 19th International Conference on
ASPLOS, pp. 269–284 (2014)
8. Akopyan, F. et al.: TrueNorth: projeto e fluxo de ferramentas de um chip neurossináptico programável de 1
milhão de neurônios de 65 mW. IEEE Trans. Computar. Projeto Auxiliado Integr. Circuitos Sist. 34, 10 (2015),
1537-1557 (2015)
9. Ienne, P.: Arquiteturas para Neurocomputadores: Revisão e Avaliação de Desempenho. Relatório técnico.
EPFL, Lausanne, Suíça (1993)
10. Em: NVIDIA Corporation. Programando Tensor Cores em CUDA 9, acessado em 2019. https://
[Link]/programming-tensor-cores-cuda-9
11. Jouppi, NP, et al.: Análise de desempenho no datacenter de uma unidade de processamento tensorial. Int. Sym.
Computar. Arquiteto. 45(2), 1–12 (2017)
12. Ben-Nun, T., Hoefler, T.: Desmistificando o aprendizado profundo paralelo e distribuído: uma análise aprofundada
da concorrência. In: Repositório de Pesquisa em Computação (CoRR) (2018)
13. Howard AG, Zhu M, Chen B, Kalenichenko D, Wang W, Weyand T, Andreetto M, Adam H: MobileNets: redes
neurais convolucionais eficientes para aplicações de visão móvel. arXiv:1704.04861 (2017)

14. Real E, Aggarwal A, Huang Y, Le QV: Evolução regularizada para busca de arquitetura de classificadores de
imagens. arXiv:1802.01548 (2018)
15. Sze V, Chen YH, Yang TJ, Emer JS: Processamento eficiente de redes neurais profundas: um tutorial e
pesquisa. proc. IEEE 105(12), 2295–2329 (2017)
16. Han, S., Mao, H. e Dally, WJ: Compressão profunda: compressão de redes neurais profundas com poda,
quantização treinada e codificação huffman. arXiv pré -impressão arXiv:1510.00149 (2015)
17. Han S, Pool J, Tran J, Dally W: Aprendendo pesos e conexões para uma rede neural eficiente. In: Avanços em
Sistemas de Processamento de Informação Neural, p. 1135–1143 (2015)
18. Mallya, A., Lazebnik, S. Packnet: Adicionando várias tarefas a uma única rede por poda iterativa. In: Proceedings
of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 7765–7773 (2018)

19. Wang, E., et al.: Aproximação de rede neural profunda para hardware personalizado: Onde estivemos, para
onde vamos. arXiv pré -impressão arXiv:1901.06955 (2019)
20. Kama S, Bernauer J, Sharma S: Integração TensorRT acelera a inferência do TensorFlow, acessado em 2019.
[Link]
Machine Translated by Google

Análise de dimensionamento de arquiteturas especializadas de processamento tensor … 97

21. Kochura, Y., Gordienko, Y., Taran, V., Gordienko, N., Rokovyi, A., Alienin, O., Stirenko, S.: Influência do tamanho
do lote no desempenho de unidades de processamento gráfico e tensor durante o treinamento e fases de
inferência. In: Hu, Z. et ai. (Eds.) Anais ICCSEEA 2019, AISC 938, p. 1–11 (2019)

[Link] Corporation. Plataforma de inferência NVIDIA AI, acessada em 2019. [Link] com/content/dam/
en-zz/Solutions/Data-Center/tesla-product-literature/t4-inference-print [Link] 23.
Blog, R, Haußmann, E.: Comparing TPUv2 do Google contra V100 da Nvidia no ResNet 50, acessado em 2019.
[Link]

24. Qi, C.: Resumo da palestra convidada: desafios e soluções para incorporar a visão AI. Em: 2018 1º Workshop sobre
Aprendizado de Máquina com Eficiência Energética e Computação Cognitiva para Aplicativos Embarcados (EMC2),
p. 2. IEEE (2018)
25. Tsimpourlas, F., Papadopoulos, L., Bartsokas, A., Soudris, D.: Uma estrutura de exploração de espaço de design
para redes neurais convolucionais implementadas em dispositivos de borda. IEEE Trans. Com colocar. Ajudado
Des. Integrar Circuitos Sist. 37(11), 2212–2221 (2018)
26. Erofei, AA, Dru¸ta, CF, Cÿaleanu, CD: Soluções embarcadas para implementação de redes neurais profundas. In:
2018 IEEE 12th International Symposium on Applied Computational Intelligence and Informatics (SACI)
000425-000430. IEEE (2018)
27. Seppälä, S.: Desempenho da classificação de imagem de rede neural em CPU e GPU móvel, acessado em 2019.
[Link] Sipi_2018.pdf

28. Ignatov A, Timofte R, Chou W, Wang K, Wu M, Hartley T, Van Gool L: Ai benchmark: Running deep neural networks
em smartphones Android. In: Conferência Europeia sobre Visão Computacional, p. 288-314. Springer, Cham (2018)

29. Zhu H, Zheng B, Schroeder B, Pekhimenko G, Phanishayee A: DNN-Train: Benchmarking and Analyzing DNN
Training, acessado em 2019. [Link] .pdf

30. Jäger, S., Zorn, HP, Igel, S., Zirpins, C.: Treinamento paralelo de Deep NN: comparação de conceitos e frameworks
atuais. In: Proceedings of the Second Workshop on Distributed Infrastructures for Deep Learning, pp. 15-20. MCA
(2018)
31. Goyal P, Dollar P, Girshick RB, Noordhuis P, Wesolowski L, Kyrola A, Tulloch A, Jia Y, He K: Preciso, Grande
Minilote SGD: Treinamento ImageNet em 1 hora. arXiv:1706. 02677 (2017)

32. You Y, Zhang Z, Hsieh C, Demmel J: Treinamento ImageNet de 100 épocas com AlexNet em 24
Minutos. arXiv:1709.05011 (2017)
33. Le QV, Ngiam J, Coates A, Lahiri A, Prochnow B, Ng AY: Sobre métodos de otimização para aprendizado profundo.
In Proceedings 28th International Conference on Machine Learning, pp. 265–272 (2011)

34. Krizhevsky, A.: Um truque estranho para paralelizar redes neurais convolucionais. pré-impressão arXiv
arXiv:1404.5997 (2014)
35. Smith SL, Kindermans P, Le QV: Não diminua a taxa de aprendizado, aumente o tamanho do lote. arXiv:1711.00489
(2017)
36. You, Y., Gitman, I., Ginsburg, B.: Treinamento de grandes lotes de redes convolucionais. arXiv:1708.
03888 (2017)
37. Masters, D., Luschi, C.: Revisitando o treinamento em pequenos lotes para redes neurais profundas. arXiv pré
-impressão arXiv:1804.07612 (2018)
38. Devarakonda A, Naumov M, Garland M: AdaBatch: tamanhos de lote adaptáveis para treinamento de redes neurais
profundas. arXiv pré -impressão arXiv:1712.02029 (2017)
39. Smith, LN: Uma abordagem disciplinada para hiperparâmetros de rede neural: Parte 1 - taxa de aprendizado,
tamanho do lote, momento e queda de peso. arXiv pré -impressão arXiv:1803.09820 (2018)
40. Kochura, Y., Stirenko, S., Alienin, O., Novotarskiy, M., Gordienko, Y., Análise de desempenho de estruturas de
aprendizado de máquina de código aberto para vários parâmetros nos modos single-thread e multi-thread. In:
Avanços em Sistemas Inteligentes e Computação II. CSIT 2017.
Avanços em Sistemas Inteligentes e Computação, 689, p. 243-256. Springer, Cham (2017)
Machine Translated by Google

98 Y. Gordienko et ai.

41. Kochura, Y., Stirenko, S., Gordienko, Y.: Análise comparativa de desempenho de arquiteturas de redes neurais na
plataforma H2O para várias funções de ativação. In: 2017 IEEE International Young Scientists Forum on Applied
Physics and Engineering, p. 70–73 (2017)
42. Kochura, Y., Stirenko, S., Alienin, O., Novotarskiy, M., Gordienko, Y.: Análise comparativa de frameworks de código
aberto para aprendizado de máquina com caso de uso em modos single-thread e multi-thread. In: 12th IEEE
International Scientific and Technical Conference on Computer Sciences and Information Technologies (CSIT), 1,
pp. 373–376 (2017)
43. Jouppi, N., Young, C., Patil, N., Patterson, D.: Motivação e avaliação do primeiro tensor
unidade de processamento. IEEE Micro 38(3), 10–19 (2018)
44. Dumoulin, V., Vision, F.: Um guia para aritmética de convolução para aprendizado profundo. arXiv:1603.07285
(2016)
45. Ioffe, S., Szegedy, C.: Normalização em lote: acelerando o treinamento de rede profunda reduzindo o deslocamento
covariável interno. In: Anais da 32ª Conferência Internacional sobre Aprendizado de Máquina, p. 448–456 (2015)

46. He K, Zhang X, Ren S, Sun J: Aprendizado residual profundo para reconhecimento de imagem. In: IEEE Conference
on Computer Vision and Pattern Recognition, pp. 770–778 (2016)
47. Huang G, Liu Z, van der Maaten L, Weinberger KQ: Redes convolucionais densamente conectadas. In: Proceedings
IEEE Conference on Computer Vision and Pattern Recognition (2017)

48. Oyama, Y., et al.: Previsão de estatísticas de parâmetros SGD assíncronos para um sistema de aprendizado
profundo distribuído em larga escala em supercomputadores GPU. In: IEEE International Conference on Big Data
(Big Data), p. 66–75 (2016)
49. Viebke, A., Memeti, S., Pllana, S., Abraham, A.: CHAOS: um esquema de paralelização para treinamento de redes
neurais convolucionais no Intel Xeon Phi. J. Supercomputador. (2017)
50. Yan, F., Ruwase, O., He, Y., Chilimbi, T.: Modelagem de desempenho e otimização de escalabilidade de sistemas
distribuídos de aprendizado profundo. In: Proceedings 21st ACM International Conference on Knowledge
Discovery and Data Mining, p. 1355–1364 (2015)
51. Qi H, Sparks ER, Talwalkar A: Paleo: um modelo de desempenho para redes neurais profundas. In: Proceedings
International Conference on Learning Representations (2017)
52. Demmel J, Dinh G: Redes neurais convolucionais ótimas de comunicação. arXiv:1802.06905
(2018)
53. Seide F, Fu H, Droppo J, Li G, Yu D: Sobre a paralelização da descida do gradiente estocástico para DNNs de fala.
In: IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 235–239 (2014)

54. Awan AA, Bedorf J, Chu CH, Subramoni H, Panda DK: Treinamento DNN Scalable Distribuído usando TensorFlow
e CUDA-Aware MPI: Caracterização, Projetos e Avaliação de Desempenho. arXiv pré -impressão arXiv:1810.11112
(2018)
55. LeCun, Y., Cortes, C., Burges, CJ : banco de dados de dígitos manuscritos MNIST, acessado em 2019. http://
[Link]/exdb/mnist 56. Simonyan, K., Zisserman, A.: Very redes convolucionais profundas para coleta de
imagens em larga escala. In: Representações de Aprendizagem de Conferências Internacionais (2015)

57. Sabour, S., Frostt, N., Hinton, GE: roteamento dinâmico entre cápsulas. In: Avanços em Neural
Sistemas de Processamento de Informação, p. 3856–3866 (2017)
58. Abadi, M., et al.: Tensorflow: um sistema para aprendizado de máquina em larga escala. In: 12º Simpósio USENIX
sobre Projeto e Implementação de Sistemas Operacionais, p. 265–283 (2016)
59. Sornette, D.: Fenômenos Críticos em Ciências Naturais: Caos, Fractais, Auto-organização e
Desordem: Conceitos e Ferramentas. Springer Science & Business Media (2006)
60. Badii, R., Politi, A.: Complexidade: Estruturas Hierárquicas e Escala em Física, Vol. 6. Cam
ponte University Press (1999)
61. Mantegna, RN, Stanley, HE: Econofísica: dimensionamento e seu colapso nas finanças. J. Stat.
Físico 89(1–2), 469–479 (1997)
62. Barabási, AL, Albert, R.: Emergência de dimensionamento em redes aleatórias. Ciência 286 (5439),
509–512 (1999)
Machine Translated by Google

Análise de dimensionamento de arquiteturas especializadas de processamento tensor … 99

63. GB West, JH Brown, BJ Enquist: A origem das leis de escala universal na biologia. Biologia de Escala,
87-112 (2000)
64. Cardy, J.: Escala e Renormalização em Física Estatística, Vol. 5. Universidade de Cambridge
Imprensa (1996)
65. Gordienko, YG: Simulação de dinâmica molecular da evolução da subestrutura de defeitos e mecanismos
de deformação plástica em nanocristais de alumínio. Metalofiz. Noveishie Tekhnol. 33(9), 1217–1247
(2011)
66. Torabi, A., Berg, SS: Escala de atributos de falha: uma revisão. Mar. Pet. Geol. 28(8), 1444-1460
(2011)
67. Gordienko, YG: Mudança de escala e aparência de distribuição de tamanho sem escala na agregação.
cinética por regras aditivas. Física A 412, 1-18 (2014)
68. Gordienko, YG: Modelo generalizado de crescimento agregado impulsionado pela migração –
distribuições assintóticas, leis de potência e aparente fractalidade. Int. J. Mod. Phys. B 26(01), 1250010 (2012)
69. Yu J, Tian S: Uma revisão da compressão de rede com base na poda profunda da rede. In: 3ª Conferência
Internacional de Engenharia Mecatrônica e Tecnologia da Informação (ICMEIT 2019). Atlantis Press
(2019)
70. Cheng J, Wang PS, Li G, Hu QH, Lu HQ: Avanços recentes na computação eficiente de redes neurais
convolucionais profundas. Frente. Tecnol. Elétron. Eng. 19(1), 64–77 (2018)
71. Zhu, M., Gupta, S.: Podar ou não podar: explorando a eficácia da poda para modelo
compressão. arXiv pré -impressão arXiv:1710.01878 (2017)
72. Gordienko Yu., Kochura Yu., Taran V., Gordienko N., Bugaiov A., Stirenko S.: Poda de canal iterativa
adaptativa para acelerar redes neurais profundas. XI Conferência Científica e Prática Internacional
sobre Eletrônica e Tecnologias da Informação, Lviv, Ucrânia, 16 a 18 de setembro de 2019 (aceito)

73. Li Y, Liu Z, Xu K, Yu H, Ren F: Uma arquitetura de acelerador FPGA com desempenho superior a GPU
para redes neurais convolucionais binárias. ACM J. Emerg. Tecnol. Computar. Sistema 14(2), 1–16
(2018)
Machine Translated by Google

Avaliação de Arquiteturas de Autoencoder

para Representação de Dados

Karishma Pawar e Vahida Z. Attar

Resumo O aprendizado de representação eficiente da distribuição de dados é parte integrante

da execução bem-sucedida de qualquer modelo baseado em aprendizado de máquina.
Autoencoders são bons para aprender a representação de dados com dimensões mais baixas.
Tradicionalmente, os codificadores automáticos têm sido amplamente utilizados para compactação
de dados para representar os dados estruturais. A compressão de dados é uma das tarefas mais
importantes em aplicações baseadas em Visão Computacional, Recuperação de Informação,
Processamento de Linguagem Natural, etc. O objetivo da compactação de dados é converter os
dados de entrada em uma representação menor, mantendo a qualidade dos dados de entrada.
Muitas técnicas de compactação de dados com e sem perdas, como compactação Flate/deflate,
compactação Lempel–Ziv–Welch, compactação Huffman, compactação de codificação Run-
length, compactação JPEG estão disponíveis. Da mesma forma, os autoencoders são redes
neurais não supervisionadas usadas para representar os dados estruturais por compactação de
dados. Devido à ampla disponibilidade de chips de processamento de ponta e grandes conjuntos
de dados, o aprendizado profundo ganhou muita atenção da academia, indústrias e centros de
pesquisa para resolver vários problemas. Considerando a literatura de ponta, os autoencoders
são arquiteturas amplamente utilizadas em muitas aplicações de deep learning para representação
e aprendizado múltiplo e servem como uma opção popular para redução de dimensionalidade.
Portanto, este capítulo visa esclarecer a aplicabilidade de variantes de autoencoders para vários
domínios de aplicação. Neste capítulo, arquitetura básica e variantes do autoencoder viz.
Autoencoder convolucional, autoencoder variacional, autoencoder esparso, autoencoder
empilhado, autoencoder profundo, para citar alguns, foram minuciosamente estudados. Como o
tamanho da camada e a profundidade do modelo de autoencoder profundo afetam o desempenho
geral do sistema também foi discutido. Também descrevemos a adequação de várias arquiteturas
de autoencoder para diferentes áreas de aplicação. Isso ajudaria a comunidade de pesquisa a
escolher a arquitetura de autoencoder adequada para o problema a ser resolvido.

K. Pawar (B) VZ Attar (B)

Departamento de Engenharia de Computação e TI, Faculdade de Engenharia de Pune (COEP), Pune, Índia
e-mail: kvppawar@[Link]

VZ Attar
e-mail: [Link]@[Link]

© Springer Nature Switzerland AG 2020 101

W. Pedrycz e S.-M. Chen (eds.), Deep Learning: Concepts
and Architectures, Studies in Computational Intelligence 866,
[Link]
Machine Translated by Google

102 K. Pawar e VZ Attar

Palavras -chave Autoencoders · Deep learning · Redução de dimensionalidade ·

Aprendizagem de representação Representação de dados

1. Introdução

A representação de dados desempenha um papel crucial na concepção de um bom modelo e eventual

sucesso de algoritmos de aprendizado de máquina. No aprendizado de máquina, o aprendizado de
representação permite que um sistema descubra automaticamente as representações de dados necessárias
para a detecção de recursos a partir de dados brutos de entrada. A dimensionalidade da representação
aprendida dos dados é um aspecto importante, pois o desempenho do modelo tende a diminuir com o
aumento do número de dimensões necessárias para representar a distribuição dos dados. Portanto, mais
ênfase tem sido dada às técnicas de aprendizado de representação pelos pesquisadores em todo o mundo
para realizar o aprendizado de recursos e a fusão de recursos resultando em representações compactas e
abstratas de dados [1].
Uma infinidade de técnicas específicas de domínio foram desenvolvidas para aprender a representação
de dados em abstração compacta e de alto nível. As técnicas mais convencionais, como Análise de
Componentes Principais (PCA) e Alocação de Dirichlet Latente (LDA) usam transformação linear para
representação de dados.
Os autoencoders (AEs) são bons em redução de ruído e dimensionalidade de dados.
Eles funcionam como técnicas de redução de dimensionalidade, como o PCA, que projetam dados
dimensionais mais altos para um espaço dimensional mais baixo e preservam as características salientes
dos dados. No entanto, o PCA e os autoencoders variam entre si na transformação que aplicam. O PCA
aplica a transformação linear, enquanto os autoencoders aplicam transformações não lineares.
Autoencoders são piores em compactação do que métodos tradicionais como JPEG, MP3 e MPEG, etc.
Como as funções de compactação e descompactação usadas em autoencoders são específicas de dados,
os autoencoders têm problemas para generalizar para conjuntos de dados diferentes daqueles em que
foram treinados.
Na busca por Inteligência Artificial, o aprendizado profundo acabou sendo a principal solução aplicável
para resolver problemas complexos no domínio do processamento de linguagem natural [2], modelagem
de tópicos [3, 4], detecção de objetos [5-7], vídeo analítica [8, 9], classificação de imagem [10], previsão
[11], etc. para citar apenas alguns.
Autoencoders tornaram-se a alternativa popular para representação e aprendizado múltiplo de distribuição
de dados em abordagens de aprendizado profundo. Devido a isso, muitas variantes de arquiteturas de
autoencoder foram apresentadas com características específicas aplicáveis em aprendizado de recursos
não supervisionado e aprendizado profundo.
Este capítulo fornece uma elaboração detalhada do que é autoencoder, taxonomia de autoencoders,
aplicações de domínio e fatores que regulam o funcionamento de autoencoders. A maior contribuição foi
apresentada na Figura 1 como tema central deste capítulo e pode ser destacada a seguir.

• Estudo aprofundado de arquiteturas e variantes de autoencoder de última geração, como AE

convolucional, AE regularizado, AE variacional, AE esparso, AE empilhado, AE profundo, AE generativo,
etc. foi realizado neste capítulo.
Machine Translated by Google

Avaliação de Arquiteturas de Autoencoder … 103

Autoencoder e Taxonomia Gráfica Variantes de Autoencoders

Arquitetura geral e taxonomia gráfica Autoencoders específicos do aplicativo,
baseada em variantes, estrutura de rede, Autoencoders regularizados,
métodos de treinamento, implementação Autoencoders robustos tolerantes a ruído,
e regularização Autoencoders generativos

Avaliação de
codificador automático
Arquiteturas

formulários fatores
Aplicações de autoencoders em Fatores que afetam o desempenho
visão computacional, inteligência artificial, dos autoencoders, como treinamento,
processamento de linguagem natural, função objetivo, função de ativação,
sistemas baseados em física, análise de big data tamanho da camada e profundidade da rede

Fig. 1 Tema central para avaliação de arquiteturas de autoencoder

• A taxonomia dos autoencoders correspondentes aos fatores necessários para o projeto

eles também foram apresentados.
• O impacto do tamanho da camada, profundidade no desempenho do modelo foi avaliado.
• A aplicabilidade de variantes de arquiteturas de autoencoder para diferentes tarefas
também foram apresentados na forma tabulada.

O conteúdo deste capítulo está estruturado da seguinte forma. A Seção 2 fornece uma visão geral
de arquitetura geral e taxonomia proposta dos autoencoders. variantes de
autoencoders foram discutidos na Seção 3. A Seção 4 trata de fatores como
procedimentos de treinamento, estratégias de regularização que afetam a funcionalidade de modelos
baseados em autoen coder. As características dos autoencoders juntamente com sua adequação
para a aplicação ou tarefa foram resumidas na Seção 5. A conclusão é mencionada
na Seção 6.

2 Arquitetura Geral e Taxonomia de Autoencoders

Autoencoders são arquiteturas de rede neural autossupervisionadas que são usadas para
realizar compactação de dados em que as funções de compactação e descompactação são
(i) com perdas (ii) específicos dos dados e (iii) aprendidos com os próprios dados. Para construir um
autoencoder, três coisas, a saber, uma função de codificação, uma função de decodificação e
uma função de distância são considerados. A função de distância é usada para calcular a
perda de informação entre a representação comprimida e a entrada original. a
codificador e decodificador são escolhidos para serem funções paramétricas (expressas via neural
redes) e ser diferenciável por função de distância. Isso permite a otimização
Machine Translated by Google

104 K. Pawar e VZ Attar

Original Latente/ Comprimido reconstruído

Entrada representação Entrada

Codificador Decodificador

x h r
Fig. 2 Arquitetura geral de um autoencoder

de parâmetros em funções de codificador e decodificador. A perda de reconstrução pode ser

minimizada usando otimizadores apropriados como Stochastic Gradient Descent (SGD).
A ideia geral do autoencoder é passar um dado de entrada para um codificador para fazer a
representação compactada da entrada. A função de codificação pode ser representada como h = f
(x) onde h é a representação latente. A camada intermediária, também conhecida como “camada de
gargalo”, é a representação compactada de dados a partir da qual os dados originais podem ser
reconstruídos. A representação comprimida h é passada para o decodificador para recuperar os
dados reconstruídos r. A função de decodificação é dada por r = g(h).
O codificador e o decodificador são construídos usando redes neurais. Toda a rede é treinada
minimizando a diferença entre entrada e saída. Pode haver alguma perda de informação devido a
menos unidades. Todo o autoencoder é representado matematicamente por g( f (x)) = r. A Figura 2
mostra a arquitetura geral de um autoencoder.

A função de perda para o autoencoder é dada como

L = |x ÿ g( f (x))| (1)

onde x é a entrada tal que x ÿ Rd e x geralmente é calculada a média sobre algum conjunto de
treinamento de entrada. A perda L penaliza a função g( f (x)) por ser diferente de x. Essa perda L
pode ser definida como regularização L2 de sua diferença. Mantendo o tamanho da representação
latente pequeno e escolhendo a capacidade adequada das funções de codificação e decodificação,
qualquer arquitetura de autoencoder pode ser bem treinada. A Figura 3 mostra a taxonomia de
autoencoders com base em vários fatores a serem considerados para projetar os autoencoders. Os
detalhes dos componentes descritos na Fig. 3 foram fornecidos nas seções subsequentes deste
capítulo.

3 Variantes de Autoencoders

Dependendo do número de camadas ocultas presentes, os autoencoders podem ser superficiais ou

profundos. AEs rasos têm camada de entrada, camada oculta única e camada de saída. EA profundos
Machine Translated by Google

Avaliação de Arquiteturas de Autoencoder … 105

Fig. 3 Taxonomia de autoencoders

tem várias camadas ocultas. Com base na dimensionalidade do vetor espacial latente
(representação) h, os autoencoders podem ser classificados como autoencoders subcompletos
e supercompletos. É mais importante e útil treinar o autoencoder para executar a tarefa de
copiar uma entrada para a saída restringindo a representação latente. Um autoencoder cuja
dimensão do vetor espacial latente h é menor que a dimensão da entrada é chamado de
subcompleto. Com o autoencoder incompleto, um modelo é forçado a aprender os recursos
mais essenciais dos dados de treinamento. Se as funções de codificação e decodificação
receberem muita capacidade, o autoencoder executará a tarefa de copiar a entrada para a
saída sem aprender os recursos essenciais da distribuição de dados. Esse problema surge
quando as dimensões de representação latente são iguais às dimensões de entrada e, no caso
de autoencoders supercompletos, as dimensões de representação latente são maiores que as
dimensões de entrada. Os autoencoders podem ser implementados como unidades totalmente
conectadas, baseadas em convolução ou baseadas em recorrentes. As variantes de
autoencoders foram discutidas seguindo as categorias como EAs específicos de aplicação, EAs
regularizados, EAs robustos tolerantes a ruído e EAs generativos. Muitas variantes de autoencoders
Machine Translated by Google

106 K. Pawar e VZ Attar

foram apresentados até a data em cada uma das categorias mencionadas. Neste capítulo,
autoencoders amplamente utilizados foram discutidos.

3.1 Autoencoders específicos do aplicativo

codificador automático de baunilha

Esta é a forma mais simples de autoencoder com 3 camadas de rede neural viz. entrada
camada para codificação, camada oculta representando a representação compactada e
camada de saída para decodificação. A Figura 4 mostra a arquitetura do autoencoder vanilla.
Normalmente, uma única camada não é suficiente para aprender o discriminativo e representativo
recursos dos dados de entrada. Portanto, os pesquisadores empregam codificadores profundos (multicamadas ou
deep) para melhor aprendizado de representação e redução de dimensionalidade. Hinton et ai.
[11] primeiro propôs o autoencoder profundo para redução de dimensionalidade.

codificador automático profundo

Deep autoencoder [11] constitui duas redes de crenças profundas simétricas para codificação e decodificação,
cada uma com 4-5 camadas rasas. Máquina Boltzmann restrita
(RBM) atua como o bloco básico da rede de crenças profundas. O autoencoder profundo funciona
em 3 fases como pré-treino, desenrolamento e ajuste fino.
Inicialmente, uma pilha de RBMs com uma camada para detecção de recursos é usada para pré-treinamento
de tal forma que as ativações de recursos geradas pelo primeiro RBM são usadas como
entrada para o próximo RBM. Esses RBMs são desenrolados após o pré-treinamento para obter uma profunda
autoencoder que pode ser ajustado usando back-propagation. A Figura 5 mostra o
projeto de autoencoder profundo que é obtido desenrolando a pilha de RBMs.

Codificador Decodificador

reconstruído
Original
Entrada Entrada

Camada oculta
"gargalo"

Fig. 4 Arquitetura do autoencoder vanilla

Machine Translated by Google

Avaliação de Arquiteturas de Autoencoder … 107

Entrada reconstruída

T
W1
2000
T
W2
1000 Decodificador
T

W3500 _
T
W4
dormente
30
representação
W4
500

W3
1000 Codificador

W2
2000
W1

Entrada Original

Fig. 5 Autoencoder profundo [11]

Autoencoder divergente (DIVA)

Autoencoder divergente [12] é bom para resolver as tarefas de classificação N-way. Ele
transforma a entrada em espaço representacional distribuído. O desvio entre a entrada
reconstruída e a original é usado para classificação.

Autoencoder convolucional (CONV AE)

Em vez de usar camadas totalmente conectadas, os operadores de convolução usados no

autoencoder convolucional extraem uma representação útil dos dados de entrada. Neste, a
imagem de entrada é reduzida para obter a representação latente com dimensões menores e o
codificador automático é forçado a aprender a representação compactada da imagem. A Figura
6 mostra o funcionamento do autoencoder convolucional.
O codificador é implementado como uma pirâmide convolucional típica na qual cada camada
de convolução é seguida pela camada de agrupamento máximo para reduzir as dimensões de
uma imagem. Conforme mostrado na Fig. 6, as dimensões da imagem de entrada em escala de
cinza são 28 × 28 × 1 (vetor com 784 dimensões). Pela aplicação sucessiva de camadas de
convolução e max-pooling, a representação latente reduzida da imagem com dimensões
Machine Translated by Google

108 K. Pawar e VZ Attar

Entrada reconstruída

Convolução 28×28×1

Convolução 28×28×16

28×28×8 Upsample

Convolução 14×14×8 Decodificador

14×14×8 Upsample

Convolução 7×7×8

7 × 7 × 8 Upsample
dormente
4×4×8 MaxPool
representação
Convolução 7×7×8

7×7×8MaxPool

Convolução 14×14×8
Codificador
14×14×16 MaxPool

Convolução 28×28×16

28×28×1 entrada

Entrada Original

Fig. 6 Arquitetura do autoencoder convolucional [69]

4 × 4 × 8 é obtido. O decodificador converte uma representação estreita da imagem em uma imagem

ampla reconstruída com dimensões 28 × 28 × 1 por aplicação sucessiva de upsampling e convolução
transposta. A compressão é com perdas no autoencoder convolucional. Geralmente, a conversão da
representação estreita da imagem em uma imagem expandida pode ser feita usando 2 maneiras, viz.
upsampling e convolução transposta (deconvolução). O upsampling realiza o redimensionamento da
imagem esticando-a. As técnicas como interpolação do vizinho mais próximo ou interpolação bilinear são
usadas para upsampling.
Como afirmado em [13], a interpolação do vizinho mais próximo funciona melhor para upsampling.
A convolução transposta funciona exatamente como as camadas de convolução, mas de maneira inversa.
Por exemplo, a convolução de um kernel 3 × 3 sobre um patch de imagem de tamanho 3 × 3 resultaria em
um patch de uma unidade na camada de convolução. Ao contrário, uma unidade de patch na camada de
entrada se expandiria para um patch de 3 × 3 na convolução transposta. aplicando
Machine Translated by Google

Avaliação de Arquiteturas de Autoencoder … 109

a convolução transposta nas imagens resulta na geração de artefatos quadriculados nas imagens reconstruídas [13].

Para extrair com precisão as informações de uma rede, muitos problemas no domínio da visão computacional,
análise de redes sociais e processamento de linguagem natural são representados usando o gráfico ou a estrutura
da rede. Autoencoder convolucional de subgrafo baseado em profundidade (DS-CAE) [14] modela informações de
conteúdo de nós e estrutura de rede para aprendizado de representação de rede. Ele mapeia gráficos para espaços
não lineares de alta dimensão, preservando as informações locais e globais no espaço original. Ele usa filtros de
convolução para extrair os recursos locais por convolução sobre o conjunto completo de subgrafos de um vértice.

EA baseado em RNN

Problemas de predição de sequência são difíceis de lidar, pois o comprimento das sequências de entrada varia em
problemas de predição de sequência e a maioria das redes neurais requer entrada de comprimento fixo para
processamento. Outro desafio é que a ordenação temporal das observações torna a extração de recursos uma tarefa
difícil, pois fornecer uma entrada para modelos de redes neurais supervisionadas precisa de conhecimento de
domínio. Muitos aplicativos baseados em modelagem preditiva precisam de previsão como saída, que por si só é
uma sequência. Portanto, redes neurais recorrentes (RNNs), como Long Short-Term Memory (LSTM), são projetadas
para suportar dados de sequência como entrada. O modelo RNN Encoder-Decoder proposto em [15] é bom para
lidar com o problema de predição de sequência como a tradução automática estatística. O codificador e o
decodificador neste modelo são construídos usando redes neurais recorrentes.

No AE baseado em RNN, a sequência de entrada de comprimento variável é mapeada para vetor de comprimento
fixo usando o codificador. Esse vetor de comprimento fixo é mapeado de volta para a sequência de saída de
comprimento variável usando o decodificador. Tanto o codificador quanto o decodificador foram treinados em
conjunto para maximizar a probabilidade da sequência de saída dada uma sequência de entrada.

Autoencoder LSTM

Srivastava et ai. [16] descreveram o autoencoder LSTM como uma extensão do AE baseado em RNN para aprender
a representação de dados sequenciais de séries temporais, áudio, texto e vídeos. Neste modelo, o codificador e o
decodificador são construídos usando LSTM. O codificador LSTM aceita uma sequência de vetores na forma de
imagens ou recursos. O decodificador LSTM recria a sequência alvo dos vetores de entrada na ordem inversa.
Conforme alegado pelos autores, recriar a sequência de entrada na ordem inversa torna o processo de otimização
mais tratável. Decoder é projetado usando 2 maneiras viz. condicional e incondicional.

Um decodificador condicional recebe o quadro de saída previamente construído como entrada, enquanto o
decodificador incondicional não recebe o quadro de saída criado anteriormente.

Autoencoder composto LSTM

O autoencoder composto LSTM [16] executa tanto as tarefas de reconstrução da sequência de quadros de vídeo
quanto a previsão do próximo quadro de vídeo. Neste, o codificador LSTM representa tal estado com base no qual
os próximos quadros podem ser previstos e os quadros de entrada podem ser reconstruídos.
Machine Translated by Google

110 K. Pawar e VZ Attar

3.2 Autoencoders Regularizados

Autoencoder regularizado (RAE)

Autoencoders regularizados usam uma função de perda para que o modelo suporte as seguintes
propriedades como capacidade de reconstruir a entrada aprendendo a distribuição de dados,
representação esparsa e robustez para lidar com dados ruidosos [17]. Embora o modelo possa
servir como um autoencoder não linear e supercompleto, ele ainda pode aprender os recursos
salientes da distribuição dos dados de entrada.

Autoencoder esparso (SAE)

Autoencoders esparsos são usados para extrair os recursos esparsos dos dados de entrada.
As duas maneiras de impor a restrição de esparsidade na representação podem ser dadas como
segue. (i) aplicar penalidade nos vieses das unidades ocultas [18, 19] (ii) penalizar a saída de
ativação do espaço latente (unidade oculta) [20]. Em autoencoders esparsos [18, 21] unidades
ocultas são mais do que unidades de entrada, embora apenas um pequeno número de unidades
ocultas possa estar ativo em algum momento. Autoencoders esparsos impõem penalidade de
esparsidade (h) na camada oculta, além do erro de reconstrução para impedir que a camada de
saída copie os dados de entrada. Portanto, a função de perda pode ser dada como mostrado na
Eq. (2) onde (h) é a penalidade de esparsidade.

L = |x ÿ g( f (x))| + (h) (dois)

Uma variante do autoencoder esparso, especificamente o codificador esparso conectado

localmente de 9 camadas com agrupamento e normalização de contraste local, foi apresentada em [22].
O modelo treinado usando esse autoencoder realiza a detecção de rosto usando dados não
rotulados. Este autoencoder é invariável à translação, escala e rotação fora do plano.
Muitos trabalhos de pesquisa se concentraram na aprendizagem de representação a partir dos
dados. Algoritmos de representação de recursos baseados em autoencoder não-negativo e SAE
causam redundância de recursos e overfitting devido a campos receptivos de codificação e
decodificação duplicados. Autoencoders regularizados baseados em variância cruzada regularizam
os vetores de peso de recursos para aliviar a redundância de recursos e reduzir o overfitting [23].

Autoencoder empilhado

Uma rede neural com várias camadas de autoencoder esparso é conhecida como autoencoder
empilhado. Adicionar mais camadas ocultas a um autoencoder causa redução de dados de alta
dimensão. Isso permite que uma representação compactada exiba as características salientes dos
dados, de modo que cada camada i tenha uma representação mais compacta do que a camada no
nível i ÿ 1. No autoencoder empilhado, cada camada sucessiva no modelo é otimamente ponderada
e não linear.

Autoencoder de saturação (SATAE)

A saturação do autoencoder [24] restringe a capacidade do autoencoder de reconstruir os dados

de entrada que não estão próximos ao coletor de dados. Ele atua como um regularizador de estado
latente para os autoencoders cujas funções de ativação do espaço latente possuem pelo menos um
Machine Translated by Google

Avaliação de Arquiteturas de Autoencoder … 111

região saturada com gradiente zero. Autoencoders esparsos e saturados regularizam seus estados
latentes para evitar que o autoencoder aprenda a reconstrução dos dados de entrada e, assim, se
concentra em melhorar o poder expressivo dos autoencoders para representar o coletor de dados.

Hessian regularized sparse autoencoder (HSAE)

HSAE [25] engloba três termos viz. erro de reconstrução, restrição de esparsidade e regularização
hessiana. O erro de reconstrução calcula a perda entre a amostra de entrada e a amostra reconstruída.
A restrição de esparsidade permite aprender a representação oculta dos dados e torna o modelo robusto
ao ruído. A regularização hessiana preserva a estrutura local e controla os codificadores aprendidos
linearmente variáveis ao longo da variedade de distribuição de dados. Este autoencoder pode ser
melhorado para suportar dados multimídia em grande escala paralelizando o algoritmo do autoencoder.

Autoencoder contrativo (CAE)

Rifai et ai. [26] apresentaram um modelo de autoencoder contrativo com o objetivo de aprender a
representação robusta de dados. O regularizador explícito é adicionado na função objetivo do autoencoder
contrativo para tornar o modelo robusto a pequenas variações nos dados de entrada.
A equação (3) [17] mostrando a função de perda do autoencoder contrativo é dada como

dois

ÿf(x)
L = |x ÿ g( f (x))| + (h) = |x ÿ g( f (x))| + ÿ (3)
ÿx
F

onde o termo de penalidade (h) para a camada oculta é calculado com a entrada x que é conhecida
como norma de Frobenius da matriz Jacobiana. A soma do quadrado de todos os elementos é dada pela
matriz Jacobiana. Autoencoders de contração são melhores do que autoencoders de redução de ruído
para aprendizado de recursos. O mapeamento gerado pelo termo de penalidade resulta em forte
contração de dados e, portanto, é denominado como autoencoder contrativo.

CAE de ordem superior

Rifai et ai. [27] estendeu a abordagem do autoencoder contrativo para melhorar a robustez de dados
corrompidos e estabilizar a representação aprendida em torno dos pontos de treinamento para
aprendizado múltiplo. Eles executaram explicitamente a regularização da representação do estado
latente usando derivada de primeira ordem (norma Jacobiana) e derivada de segunda ordem (norma
Hessiana) para melhorar o aprendizado de recursos e otimizar o erro de classificação.

Alan et ai. [28] mencionaram que ambos os autoencoders denoising e contrativo têm critérios de
treinamento semelhantes, ou seja, o autoencoder denoising com pequeno ruído de corrupção pode ser
considerado uma variante do autoencoder contrativo onde a contração é aplicada em toda a função de
reconstrução em vez de apenas no codificador. Ambos os autoencoders suportam aprendizado não
supervisionado e de transferência [29].

Autoencoder de polarização zero

Sempre que penalidades de contração ou penalidades esparsas são usadas como estratégias de regularização
explícitas durante o treinamento em um grande número de unidades ocultas, os vieses ocultos atingem grandes
Machine Translated by Google

112 K. Pawar e VZ Attar

preconceitos negativos. A razão por trás disso é que as camadas ocultas servem ao propósito de
representar os dados de entrada e manter a representação esparsa. Portanto, para evitar os efeitos
prejudiciais de vieses negativos de grande valor, Konda et al. [30] apresentam o autoencoder de zero-
bias que atua como um regularizador implícito e permite treinar o modelo sem regularização explícita,
simplesmente minimizando a reconstrução
erro.

autoencoder k-esparso

O autoencoder k-sparse apresentado em [31] é um autoencoder com ativação linear no qual apenas
os k neurônios mais altos da camada oculta são usados para reconstruir a entrada. Este autoencoder
aproxima o algoritmo de codificação esparsa que usa “limitação iterativa com método de inversão” na
fase de recuperação esparsa. Ele impõe a dispersão em diferentes canais, conhecido como dispersão
populacional. A dispersão populacional é aplicada exatamente nas unidades ocultas e esse autoencoder
não precisa de nenhuma não linearidade e regularização.

Autoencoders Winner-Take-All (WTA)

Os Autoencoders Winner-Take-All [32] foram apresentados para representação hierárquica esparsa

de dados usando aprendizado não supervisionado. A primeira variante do WTA, ou seja, WTA
totalmente conectado (FC-WTA) impõe restrição de esparsidade de tempo de vida [33] nas ativações
de unidades ocultas com a ajuda de estatísticas de minilote. A dispersão vitalícia é aplicada em todos
os exemplos de treinamento.
Outra variante, o WTA convolucional (CONV-WTA) combina os benefícios das redes convolucionais
e dos codificadores automáticos para aprender a representação esparsa invariável de deslocamento
de dados. Ambas as variantes são escaláveis para grandes conjuntos de dados como ImageNet para
classificação e suportam aprendizado de recursos não supervisionado.

Autoencoder suave

Ao contrário dos autoencoders convencionais que reconstroem os dados da codificação, o smooth

autoencoder [34] reconstrói os vizinhos alvo da amostra usando a representação codificada de cada
amostra. Isso permite capturar recursos locais semelhantes e aprimorar a similaridade entre classes
para tarefas de classificação.

AE kernelizado profundo

A variante de AE empilhado, ou seja, Deep Kernelized AE [35] aproveita a matriz de kernel definida
pelo usuário e aprende a preservar semelhanças não lineares no espaço de entrada. Por este
autoencoder, o usuário pode controlar explicitamente a noção de similaridade nos dados de entrada
codificando-os em uma matriz de kernel semidefinida positiva. Este autoencoder é útil para tarefas de
classificação e visualização de dados de alta dimensão.

Autoencoder estruturado em gráfico

Uma versão regularizada de grafos do autoencoder foi proposta em [36]. A primeira variante deste AE
funciona de maneira não supervisionada para remoção de ruído de imagem. Outra variante, a saber, o
autoencoder de grafos regularizados de representação de baixa classificação incorpora termos de
agrupamento de subespaço em sua formulação para realizar a tarefa de agrupamento. a
Machine Translated by Google

Avaliação de Arquiteturas de Autoencoder … 113

terceira variante de EA estruturado em gráfico incorpora consistência de rótulo para resolver problemas
de classificação de rótulo único e multirrótulo em configurações supervisionadas.

Autoencoder esparso de grupo (GSAE)

Sankaran et ai. [37] propôs uma abordagem de aprendizagem de representação baseada em autoencoder
esparso de grupo. Ele funciona no modo de aprendizado supervisionado e usa as normas 1 e 2 utilizando
os rótulos de classe para aprender os recursos supervisionados para a tarefa específica. a
função de otimização neste AE funciona na abordagem de minimização de majorização. Item
executa a classificação usando a versão econômica da máquina de vetor de suporte com
rede de funções de base radial.

3.3 Autoencoders Robustos Tolerantes a Ruídos

Denoising autoencoder

Para aumentar a robustez do autoencoder às mudanças na entrada, Vincent [38,

39] apresentou um autoencoder de denoising. Em vez de penalizar a função de perda por
regularização, o ruído é adicionado à imagem x e esta imagem ruidosa x˜ é alimentada como entrada
para o autoencoder de redução de ruído. A Figura 7 fornece a arquitetura geral de remoção de ruído
codificador automático. O mapeamento estocástico é usado para fins de eliminação de ruído em AE de eliminação de ruído.
No DAE, uma cópia corrompida dos dados de entrada é criada pela introdução de algum ruído. Item
codifica a entrada e tenta desfazer o efeito de corrupção aplicado à imagem de entrada.
Este autoencoder é treinado para gerar as imagens limpas do barulhento.
Como é mais difícil gerar a imagem limpa, este modelo requer camadas mais profundas
e mais mapas de recursos. Para cada iteração do treinamento, a rede calcula
uma perda entre a imagem ruidosa reconstruída obtida do decodificador e a imagem original
imagem sem ruído e tenta minimizar a perda.

Denoising Autoencoder Auto-organizing Map (DASOM)

DASOM [40] aborda a questão de integrar as não linearidades dos neurônios em

redes para modelar funções mais complexas. Funciona interpondo uma camada

Original Adição de ruído à Latente/ Comprimido reconstruído

Entrada entrada original representação Entrada

Codificador Decodificador

~
x x h r
Fig. 7 Arquitetura do autoencoder de denoising [38]
Machine Translated by Google

114 K. Pawar e VZ Attar

de representação oculta entre o espaço de entrada e a rede neural do mapa auto-organizado. Este AE é útil no
reconhecimento óptico de imagens e texto.

Autoencoder Stacked Denoising (SDAE)

O empilhamento de DAEs para criar uma rede profunda funciona de maneira semelhante ao empilhamento de
RBMs em redes de crenças profundas [11]. No SDAE, a corrupção de entrada é aplicada a cada camada
individual para remoção de ruído inicial e treinamento para aprender os recursos mais importantes dos dados.
Após o aprendizado da função de codificação latente fÿ , ela é aplicada
Para
na entrada
treinar as
não
próximas
corrompida
camadas
em diante.
no
modelo, a entrada não corrompida das camadas anteriores é usada como entrada limpa para a próxima camada.

Autoencoders de eliminação de ruídos marginalizados (mDAE)

Em DAEs, os dados de entrada precisam ser corrompidos muitas vezes durante a fase de treinamento e isso
causa aumento no tamanho dos dados de treinamento e incorre em mais recursos computacionais. Esse
problema fica ainda pior quando a dimensionalidade dos dados de entrada é muito alta. Autoencoders
marginalizados de denoising [41] abordam esse problema marginalizando aproximadamente o processo de
corrupção de dados durante o treinamento. Ele aceita as várias cópias corrompidas dos dados de entrada em
cada iteração de treinamento e supera o DAE com poucas épocas de treinamento. Em vez de usar o processo
de corrupção de dados explícito, os mDAEs implicitamente marginalizam o erro de reconstrução sobre a
possível corrupção de dados de distribuição corrupta, como Gaussian aditivo e Mask-out/drop-out imparcial.

Autoencoder hierárquico

No DAE empilhado, apenas a camada final é responsável pela reconstrução da amostra de entrada e as
camadas intermediárias não contribuem diretamente para a reconstrução.
O autoencoder hierárquico [42] é projetado de tal forma que as camadas intermediárias fornecem
informações complementares e a saída de cada camada é fundida para obter a amostra reconstruída final. Este
autoencoder é baseado no autoencoder assimétrico no qual um autoencoder empilhado possui apenas um
decoder. A natureza superficial do decodificador alivia a necessidade de treinar várias camadas e, portanto, as
camadas podem contribuir diretamente para a reconstrução da entrada.

3.4 Autoencoders Geradores

Autoencoder Variacional (VAE)

Neste autoencoder, o vetor gargalo (vetor latente) é substituído por dois vetores, a saber, vetor de média e
vetor de desvio padrão. Autoencoders variacionais [43] são baseados em inferência Bayesiana em que a
representação comprimida segue a distribuição de probabilidade. Ao contrário dos autoencoders vanilla que
aprendem a função de codificação arbitrária para obter as características salientes, os autoencoders variacionais
aprendem os parâmetros de distribuição de probabilidade que modelam os dados de treinamento de entrada;
portanto, os VAEs são de natureza complexa. A rede do codificador é forçada a gerar os vetores latentes
Machine Translated by Google

Avaliação de Arquiteturas de Autoencoder … 115

Fig. 8 Autoencoder variacional [43]

seguindo a distribuição gaussiana unitária. Essa restrição diferencia o VAE do autoencoder padrão.

O funcionamento do autoencoder variacional é mostrado na Fig. 8. Geralmente, há uma compensação

entre a precisão com que a rede reconstrói as imagens e a proximidade das variáveis latentes com a distribuição
gaussiana unitária. O erro de reconstrução (perda generativa) é medido usando o erro quadrático médio,

enquanto a perda de divergência de Kullback–Leibler (KL) mede a proximidade de variáveis latentes com
distribuição Gaussiana unitária. Autoencoders variacionais típicos são baseados em uma forte suposição de
que a distribuição posterior é fatorial cujos parâmetros podem ser aproximados usando regressão não linear
com base em amostras observadas.

Autoencoder ponderado por importância (IWAE)

O autoencoder ponderado por importância [44] é um modelo generativo e uma variante do autoencoder
variacional. Ele tem uma arquitetura semelhante à do VAE, com a exceção de que utiliza um limite inferior de
probabilidade de log estritamente mais estreito obtido da ponderação de importância e aprende a representação
latente dos dados melhor do que o VAE.

codificador automático adversário

Autoencoder adversário [45] usa rede generativa para realizar inferência de variação para vetores latentes
contínuos e discretos em autoencoders probabilísticos. A Figura 9 mostra o autoencoder adversário que
constitui um autoencoder padrão e uma rede para treinamento de adversários. O padrão AE reconstrói uma

imagem do vetor latente h.

A rede de treinamento adversária é usada para prever discriminativamente se as amostras são emanadas de
código oculto ou distribuição especificada pelo usuário. O VAE usa a perda de divergência KL para impor
distribuição prévia no vetor de código oculto do autoencoder, enquanto o autoencoder adversário aplica o
método de treinamento adversário para combinar o posterior agregado da representação de código oculto com
a distribuição anterior.
A distribuição variada em dados de várias visualizações causa discrepância de visualização. É importante
em muitas aplicações práticas aprender as representações comuns de dados de múltiplas visualizações. Wang
et ai. [46] propôs aprendizagem de representação multi-vista não supervisionada
Machine Translated by Google

116 K. Pawar e VZ Attar

Fig. 9 Autoencoder Adversarial [45]

método, ou seja, autoencoder correlacionado adversário que aprende a representação comum de

dados multi-view.

Autoencoders Wasserstein (WAE)

A desvantagem dos autoencoders variacionais é que eles geram imagens borradas quando imagens
naturais são usadas como dados de treinamento de entrada. A qualidade visual das imagens é
bastante impressionante quando são usadas redes adversárias generativas. Mas as redes
adversárias generativas sofrem com o problema de “colapso de modo” quando um modelo treinado
não consegue aprender a variabilidade na distribuição real de dados. Os autoencoders Wasserstein
foram projetados para combinar as melhores propriedades de VAEs e GANs de maneira unificada.
WAE [47] é usado para projetar os modelos generativos com base na perspectiva de transporte
ideal. Ele penaliza a distância Wasserstein entre a distribuição do modelo e a distribuição alvo.
Neste, a distribuição de treinamento codificado é combinada com a distribuição anterior. Assim
como o autoencoder variacional, a função objetivo do WAE constitui um custo de reconstrução e um
regularizador penalizando a discrepância entre distribuição prévia e distribuição de pontos
codificados.
Machine Translated by Google

Avaliação de Arquiteturas de Autoencoder … 117

Autoencoders Adversariamente Regularizados (ARAE)

Adversarially Regularized Autoencoder [48] é baseado no WAE [47] e é uma versão estendida do Adversarial
Autoencoder [45] para suportar sequências discretas, como imagens discretizadas ou sequências de texto.
Este modelo permite manipular as variáveis no espaço latente para incorporar a mudança no espaço de
saída. Ele também lida com dados sequenciais, incorporando a distribuição anterior aprendida e fixa.

Dynecoder

Dynecoder apresentado por Yan et al. [49] representa a informação espaço-temporal de um vídeo. Constitui
três camadas. A primeira camada realiza o mapeamento da entrada xt para o estado latente ht . O próximo
estado oculto h˜t+1 é previsto pela segunda camada usando A camada final executa o mapeamento do estado
Inicialmente, cada camada
ocultoéprevisto
treinadah˜t+1
separadamente
estado atualna
ht fase
. para
degerar
pré-treinamento.
o quadro de Quando
entrada aproximado
o pré-treinamento
x˜t+1.
termina, é feito um ajuste fino da rede de ponta a ponta.

Codificador automático empilhado o que onde (SWWAE)

SWWAE [50] combina sinergicamente as vantagens dos modelos discriminativos e generativos e a

representação atua como modelo unificado para suportar o aprendizado não supervisionado,
semisupervisionado e supervisionado sem fazer uso de amostragem durante o treinamento.
Ele codifica a entrada usando a rede de convolução [51] e realiza a reconstrução usando a rede de
deconvolução [52]. Consiste em uma rede de convolução feedforward acoplada a uma rede de deconvolução
de feedback. O codificador é composto por uma camada de convolução com ativação de ReLU seguida de
uma camada de agrupamento máximo. Uma camada de pooling divide as informações em componentes
“what” e “where” que estão sendo descritos como valores máximos e posições de comutação, respectivamente.
As variáveis “what” informam a próxima camada sobre as informações incompletas sobre a posição e a
variável “where” informa ao decodificador de feedback correspondente a posição (localização) das feições
salientes. O ponto crucial deste modelo pode ser declarado como sempre que uma camada é mostrada por
meio de mapeamento muitos-para-um, esse modelo calcula variáveis complementares para reconstruir a
entrada.

4 Fatores que Afetam o Desempenho Geral dos Autoencoders

Fatores como procedimento de treinamento, regularização, funções de ativação, etc. desempenham um papel
crucial na implementação bem-sucedida de qualquer modelo baseado em autoencoder.

4.1 Treinamento

Todos os procedimentos de treinamento do autoencoder devem manter um equilíbrio entre os dois requisitos
a seguir.
Machine Translated by Google

118 K. Pawar e VZ Attar

1. Aprender uma representação latente da amostra de entrada de forma que a entrada possa ser
reconstruída via decodificador por meio de aproximação: Espera-se que o autoencoder reconstrua
a entrada seguindo a distribuição geradora de dados.
2. Cumprimento da restrição de esparsidade ou penalidade de regularização: A restrição de esparsidade
permite limitar a capacidade do autoencoder. A penalidade de regularização é necessária para
absorver propriedades matemáticas especiais nas codificações aprendidas.

Satisfazer os dois requisitos acima juntos é importante, pois eles impõem a representação oculta
para capturar os recursos salientes dos dados com base em sua distribuição.
O Autoencoder deve aprender as variações nos dados para que os dados de entrada possam ser
reconstruídos.
Autoencoders podem ser considerados como um caso especial de redes neurais feedforward e,
portanto, podem ser treinados com as mesmas técnicas das redes feedforward, como gradiente
descendente de minilote. SGD [53], e suas variantes Adam [54], AdaGrad [55] e RMSProp são alguns
algoritmos utilizados para otimização de pesos e bias em autoencoders durante o treinamento. Outros
algoritmos incluem L-BFGS e gradiente conjugado [56].

Todos esses algoritmos são baseados na técnica de gradiente descendente. O algoritmo de descida
de gradiente encontra os parâmetros de uma função f na direção do declive mais acentuado e minimiza
uma função de custo. O algoritmo de retropropagação [57] é usado para calcular os gradientes da
função de perda da última camada para uma primeira camada em uma rede neural para ajustar os
pesos.
Autoencoders podem ser treinados usando o algoritmo de treinamento de recirculação [58] que
compara as ativações da rede nos dados de treinamento e as ativações nos dados reconstruídos.
Modelos generativos implementados por meio de arquiteturas profundas geralmente seguem uma
estratégia gananciosa de pré-treinamento em camadas. Outra maneira de treinar o modelo profundo é
treinar uma pilha de autoencoders rasos. Com o crescente volume de dados não rotulados em larga
escala e a necessidade de investigar diferentes tipos de regularizadores, Zhou et al. [59] propuseram
um método de aprendizado não supervisionado para treinar conjuntamente todas as camadas do
autoencoder profundo. Neste, o objetivo único para treinar o autoencoder profundo abrange o objetivo
de reconstrução global com restrições locais em camadas ocultas para permitir o treinamento conjunto.

4.2 Função Objetivo

A função objetivo do autoencoder engloba erros de reconstrução e termos de penalidade expressos

por meio de restrições de esparsidade e/ou regularização.
O erro de reconstrução pode ser calculado usando o erro quadrático médio (MSE), entropia cruzada
e correntropia [60]. MSE dá uma diferença quadrática média entre os valores reais e previstos. A
entropia cruzada é usada para quantificar a diferença entre duas distribuições de probabilidade. A
correntropia verifica a igualdade da densidade de probabilidade de duas distribuições. A medida de
correntropia é mais robusta para os outliers do que o MSE.
Machine Translated by Google

Avaliação de Arquiteturas de Autoencoder … 119

A regularização ajuda a generalizar bem o modelo em novos dados desconhecidos. Pode ser
realizado via dados, arquitetura de rede, otimização, função de erro e termo de regularização [61]. A
eficácia dos modelos generativos pode ser melhorada pela regularização discriminativa. Neste,
algoritmos de aprendizado supervisionado aumentam os modelos generativos para discriminar quais
características dos dados valem a pena serem representadas [62]. Para entender quão bem os
autoencoders representam os dados, a função de energia [63] ou a pontuação não normalizada [64]
podem ser usadas que relacionam EA ao modelo probabilístico, como RBM. Para evitar o overfitting
dos autoencoders, o termo de regularização é adicionado à função objetivo causando o decaimento do
peso [65].
O decaimento de peso melhora a generalização ao escolher o menor vetor para superar os
componentes irrelevantes do vetor de peso. Outras formas de realizar a regularização são as restrições
de contração e esparsidade. Codificações geradas por codificadores autoen básicos não possuem
propriedades especiais. Para absorver propriedades matemáticas nessas codificações, alguns métodos
de regularização adicionam função de penalidade à função objetivo. Autoencoder esparso, autoencoder
denoising e autoencoder contrativo são alguns exemplos populares de autoencoders regularizados. Os
termos de penalidade em autoencoders regularizados podem ser a norma de Frobenius da Jacobiana
(derivada de primeira ordem) ou a norma Hessiana (derivada de ordem superior).

As penalidades de regularização podem ser aplicadas nas ativações de unidades ocultas ou na

ativação da camada de saída. Regularizadores que aplicam penalidades em ativações de unidades
ocultas são denominados regularizadores de estado latente.
Ao aprender a representação esparsa de dados, a restrição de esparsidade pode ser aplicada em
canais na amostra populacional (restrição de esparsidade populacional) [31] ou em exemplos de
treinamento (restrição de esparsidade ao longo da vida) [33]. Outra restrição, a restrição de esparsidade
espacial [32] é usada para regularizar o autoencoder, e requer a contribuição de todos os átomos do
dicionário na reconstrução dos dados de entrada. Em vez de reconstruir os dados de entrada de todas
as unidades ocultas dos mapas de recursos, a restrição de esparsidade espacial seleciona a maior
unidade oculta de cada mapa de recursos e define as unidades restantes e suas derivadas como zero.
Isso torna o nível de esparsidade igual ao número de mapas de recursos. O decodificador reconstrói a
saída com a ajuda de unidades ocultas ativas e o erro de reconstrução é retropropagado apenas por
meio dessas unidades ocultas ativas.

Autoencoders são excepcionalmente bons em aprender as propriedades/recursos dos dados. A fim

de verificar quanta informação útil é exibida pelas características construídas pelos autoencoders para
a tarefa de classificação, o método de saliência do nó do autoencoder baseado no princípio da teoria
da informação foi proposto em [66]. Neste, os nós ocultos são classificados de acordo com sua
relevância para uma tarefa de aprendizado usando o método de saliência de nó supervisionado. Além
disso, o interesse da representação latente é calculado usando a diferença de entropia normalizada
para verificar a capacidade de classificação dos nós altamente classificados.
Machine Translated by Google

120 K. Pawar e VZ Attar

4.3 Funções de Ativação

A função de ativação transforma a entrada ponderada somada na ativação do nó ou saída. Eles

desempenham um papel importante de propagar os gradientes na rede.
A função de ativação modela o comportamento não linear da maioria das redes neurais. A função
sigmóide (função logística padrão) é a função de ativação mais amplamente utilizada em
autoencoders. Outra função sigmóide - a função tangente hiperbólica é simétrica em relação à
origem. Como gera gradientes mais acentuados, deve ser preferível a outras funções de ativação
[67]. O uso de ReLU como uma função de ativação é uma escolha popular em modelos de
aprendizado profundo. Como a função ReLU produz 0 para valores negativos, ela pode prejudicar o
desempenho dos autoencoders degradando o processo de reconstrução durante a decodificação.
Unidades lineares exponenciais escalonadas (SELUs) [68] permitem treinar o modelo profundo com
várias camadas e aprender uma representação robusta empregando forte regularização. Ele aborda
a questão do desaparecimento e explosão de gradientes.
Funções de ativação como função linear, função binária e ReLU raramente são usadas em EAs.

4.4 Tamanho e Profundidade da Camada

Embora os autoencoders possam ser treinados com uma única camada de codificação e uma única
camada de decodificação, é importante treinar o autoencoder usando camadas profundas para um
melhor aprendizado de representação. Como mencionado anteriormente, tanto o codificador quanto
o decodificador no codificador autoen podem ser considerados como uma rede neural feedforward
(FNN); A camada oculta em FNN pode aproximar qualquer função com precisão arbitrária, uma vez
que a camada oculta possui nós suficientes. Isso prova que o autoencoder com uma única camada
oculta pode representar a função de identidade após a distribuição. Mas, como o mapeamento da
entrada para o estado latente (código oculto) é superficial, restrições arbitrárias não podem ser
impostas para fazer com que o código oculto siga uma representação esparsa. Um autoencoder
profundo com pelo menos uma camada oculta (com nós ocultos suficientes) é capaz de aproximar
quaisquer dados de entrada mapeando-os para o código. A profundidade da arquitetura profunda
reduz o custo computacional da representação de função/dados e reduz exponencialmente a
quantidade de dados de treinamento de entrada para aprender as funções. Autoencoders profundos
são melhores na compressão de dados do que suas contrapartes rasas ou lineares [11].

5 Aplicações de Autoencoders

Autoencoders são úteis em muitas tarefas, como classificação, previsão, aprendizado de recursos,
redução de dimensionalidade, detecção de anomalias, visualização, hashing semântico, recuperação
de informações e outros traços específicos de domínio. Alguns codificadores autoen são projetados
considerando o problema a ser resolvido.
Machine Translated by Google

Avaliação de Arquiteturas de Autoencoder … 121

A redução de dimensionalidade é uma das aplicações mais convencionais dos codificadores

autoen. Representações dimensionais mais baixas permitem melhorar o desempenho do modelo
em tarefas como classificação. O funcionamento de variantes de autoencoder tem sido amplamente
investigado para tarefas de classificação na literatura. Autoencoders como o autoencoder baseado
em RNN, o codificador LSTM são preferencialmente usados para resolver problemas de previsão
de sequência.
Autoencoders, como autoencoders convolucionais profundos, têm sido usados para detecção
de anomalias, engenharia de recursos. No caso de detecção de anomalias, os autoencoders são
treinados para dados de treinamento normais e, portanto, os dados reconstruídos também seguem
a distribuição dos dados normais e não podem gerar os dados não vistos anteriormente (padrões
anômalos). Portanto, o erro de reconstrução é tratado como um escore de anomalia. Codificadores
Autoen também foram usados para hashing semântico a ser aplicado em dados textuais e imagens.
O hash torna o processo de pesquisa mais rápido codificando os dados em códigos binários. Em
geral, os autoencoders têm sido amplamente aplicados em várias tarefas.
A Tabela 1 apresenta características de diferentes autoencoders juntamente com suas aplicações.

Tabela 1 Aplicações de autoencoders

Arquitetura características formulários

Codificador automático profundo [11, 70] Realiza pré-treinamento via Classificação, regressão,
pilha de RBMs, desenrolando a compressão, hashing semântico,
estrutura, criando um autoencoder detecção de anomalia geoquímica
profundo que pode ser
ajustado usando
retropropagação
Autoencoders convolucionais [69, Preserva a localidade espacial Reconstrução de partes faltantes
71-73] compartilhando pesos em cada em uma imagem, colorização de
camada de convolução imagens, geração de imagens de
super resolução, detecção de
anomalias, sistema de posicionamento
interno

DS-CAE [44] Executa a extração de Aprendizagem de

recursos locais em gráficos e representação de rede e gráfico
redes usando a operação de
convolução

EA baseado em RNN [15] Manipula a entrada de comprimento Tradução automática

variável e recria a saída de estatística, legendagem de imagens,
comprimento variável para dados de chat bots, geração de comandos para
sequência e aplicável para lidar com gestos de forma sequencial
problemas de previsão de sequência
a sequência

LSTM AE e Composto Reconstrói vetores/ Reconhecimento de ação,

Modelo LSTM [16] quadros de entrada e prevê os processamento de texto
próximos vetores/quadros e
aplicável para lidar com problemas
de previsão de sequência a
sequência

(contínuo)
Machine Translated by Google

122 K. Pawar e VZ Attar

Tabela 1 (continuação)

Arquitetura características formulários

Autoencoder esparso [18–20, 74] Aplica penalidade de esparsidade na Classificação, segmentação,

camada oculta para evitar que a camada inpainting, compressão, métodos de
de saída copie os dados de entrada interpolação para super-resolução

Autoencoder de saturação [24] Bom para extração de recursos, restringe a Classificação, denoising
capacidade de reconstruir as
entradas que não estão próximas ao
coletor de dados

HSAE [25] Incorpora erro de reconstrução, Classificação

restrição de esparsidade e
Regularização hessiana para
aprendizado múltiplo robusto

Codificador automático de polarização zero [30] Atua como regularizador implícito Aprendizado de recursos a partir
para aprender os recursos de de dados de alta dimensão, como
dimensão muito alta intrinsecamente vídeo e imagens

autoencoder k-esparso [31] Impõe a restrição de esparsidade na Tarefas de aprendizado

camada oculta e seleciona k discriminativo raso e profundo,
neurônios para reconstrução aprendizado de recursos não supervisionado

FC-WTA [32] Aplica a restrição de esparsidade Classificação, aprendizado de recursos

vitalícia na unidade oculta para não supervisionado
representação de dados esparsos

CONV-WTA [32] Aprende a representação esparsa Classificação, aprendizado de recursos

invariante de deslocamento de dados não supervisionado
aplicando restrições de esparsidade
espacial e de tempo de vida

AE suave [34] Reconstrói os vizinhos de destino de Representação do coletor de dados,

cada amostra pela respectiva classificação

representação codificada da amostra

Autoencoder de redução de ruído Reconstrói os dados corretos de remover marcas d'água,

[38, 39] dados de entrada corrompidos ou Pintura de imagem
ruidosos, suporta aprendizado não
supervisionado e de transferência

mDAE [41] Considera várias cópias de dados aprendizagem de representação

corrompidos e marginaliza
implicitamente o erro de reconstrução
sobre os dados

corrupção

Autoencoder hierárquico [42] Bom em lidar com análises sistemas de recomendação

e problemas de síntese devido à
natureza superficial do decodificador

(contínuo)
Machine Translated by Google

Avaliação de Arquiteturas de Autoencoder … 123

Tabela 1 (continuação)

Arquitetura características formulários

Autoencoder variacional [43, 75, 76] Gera novos dados Modelagem generativa, imputação de
aumentando os dados de amostra e dados ausentes, análise de sentimento
funciona como um típico modelo dimensional
generativo de adversários

IWAE [44] Aprende mais rico latente modelagem generativa

representação do que VAEs,
utilizando ponderação de importância

Autoencoder adversário [45] Usa o método de treinamento adversário para Redução de dimensionalidade,
inferência de variação classificação, agrupamento não
supervisionado, desembaraçar o
estilo e o conteúdo das imagens
Autoencoders Wasserstein [47] Minimiza o custo de transporte ideal modelagem generativa
em modelos generativos

ARAE [48] Funciona como modelo de variável Transferência de estilo desalinhado

latente profunda e produz representação para texto (dados discretos)
robusta para dados de sequência
discreta seguindo ambos
WAEs e autoencoders
adversários

Codificador Dinâmico [49] Captura a dinâmica de vídeo por Sintetizando texturas

representação espaço-temporal de dinâmicas de vídeo,
vídeo classificação

SWWAE [50] Aprende representação Aprendizagem de representação

fatorada usando rede de fatorada
convolução e deconvolução
para codificar propriedades de

invariância e equivariância

Autoencoder de contração [57] Aplica penalidade de contração na unidade de Classificação

ativação do estado latente, captura a

variação declarada pelos dados,

suporta aprendizado não supervisionado
e de transferência

NAFC AE [77] Cascata de autoencoders Identificação de alinhamento facial

usados para processamento de

nível grosso a fino

AE convolucional empilhado Pilha de convolucional Recursos hierárquicos
[78] autoencoder treinado usando extração, aprendizado não
gradiente descendente online supervisionado, classificação

Autoencoder para palavras [79] Realiza codificação de palavras Indexação, classificação e categorização
das palavras

(contínuo)
Machine Translated by Google

124 K. Pawar e VZ Attar

Tabela 1 (continuação)

Arquitetura características formulários

Codificador automático binário [80] Representa a camada de código oculta Hash semântico para imagens
por vetor binário, realiza a reconstrução,
segue o método de coordenadas
auxiliares

ARGA e ARGVA [81] Modelos adversários para Agrupamento de gráficos,

representar os dados do gráfico no visualização de gráficos, previsão de links
espaço dimensional inferior para
análise de gráficos

AdvCAE [46] Usa aprendizado não supervisionado Classificação de visualização cruzada e

para obter representação comum recuperação de visualização cruzada

para dados de várias visualizações

seguindo a modelagem generativa

Generative Recursive AE [82] Aprende cena hierárquica Gerando diversas cenas internas 3D em
estruturas agrupando objetos de cena grande escala
durante a codificação e geração de
cena durante a decodificação

Convolução empilhada AE, Aprende a representação Detecção de outliers no processamento

WGANs, redes siamesas [83, 84] em nível de patch de assuntos de imagens médicas, análise de
usando aprendizado de recursos não imagens de patologia
supervisionado

OtimizadoDeep Realiza extração de recursos usando Análise de fluxo de dados online,

Autoencoder + CNN [85] CNN e aprende mudanças temporais reconhecimento de ação
em fluxos de vídeo em tempo real
usando EA profundo

Autoencoder empilhado Extrai recursos espectrais e espaciais Análise HSI, detecção de

espectral-espacial [86] de imagens hiperespectrais usando anomalias de imagens hiperespectrais
AE empilhado

Média Específica da Classe Usa informações de classe de Classificação da idade adulta a partir de
Autoencoder [87] dados de amostra durante o imagens faciais
treinamento para aprender a
similaridade intraclasse e executa a
extração de recursos

AE empilhado [88, 89] Aprende recursos estruturais de Previsão de energia eólica,

diferentes estágios da rede de previsão de demanda turística
aprendizado profundo

Perceptron multicamadas com Captura relacionamentos Predição de perfis de expressão gênica

DAE empilhado [90] não lineares, interações a partir de genótipos
complexas e estruturas incorporadas

nos dados de entrada

(contínuo)
Machine Translated by Google

Avaliação de Arquiteturas de Autoencoder … 125

Tabela 1 (continuação)

Arquitetura características formulários

AE contrativo empilhado [91] Aprende subespaço não linear de imagens 2D e reconstrução facial 3D
3D, lida com mudanças de iluminação
e formas de superfície complexas em
imagens

Média Coerente Função de custo dos modelos Extração de recursos de sinais no

Autoencoder de estimativa [92] como problema de otimização domínio das interfaces cérebro-

multiobjetivo englobando reconstrução, computador

discriminação e esparsidade

termos

RODEIO [93] Utiliza a capacidade de Reconstrução de RM e TC em

aproximação de funções universais tempo real baseada em
das redes neurais e sensoriamento comprimido
processo de reconstrução
(inversão não linear) a partir de
dados de treinamento
Multimodal empilhado Preserva as relações semânticas Classificação de vídeo
EA contrativo [94] intramodalidade e intermodalidade em multimodal
etapas consecutivas de EA

AE profundo + DAE [95] Combina sinergicamente Identificação de alto-falante

Recurso de gargalo discriminante distante
baseado em Deep AE Desreverberação
baseada em DAE

CONV AE profundo distribuído [96] Aprende a estrutura hierárquica Análise de grandes

complexa de big data e aproveita o conjuntos de dados de neuroimagem
poder de processamento das GPUs
em um ambiente distribuído

AE kernelizado profundo [35] Preserva não linear Classificação, visualização de

semelhanças no espaço de entrada, dados de alta dimensão
aproveitando a matriz de kernel
definida pelo usuário

Autoencoder estruturado em gráfico Diferentes variantes de EA Denoising de imagem, clustering,

[36] estruturados em grafos, cada uma classificação de rótulo único e
seguindo aprendizado supervisionado múltiplo

ou não supervisionado

Codificador automático esparso de Aplica os padrões 1 e 2 para Classificação,

grupo [37] aprendizado de recursos supervisionado reconhecimento de impressão
digital latente necessário em
aplicações forenses e de aplicação da lei

DASOM [40] Modela funções complexas integrando Reconhecimento óptico de imagens e

não linearidades de texto
neurônios

(contínuo)
Machine Translated by Google

126 K. Pawar e VZ Attar

Tabela 1 (continuação)

Arquitetura características formulários

AE cruzado convolucional [97] O Cross AE lida com Análise de mídia cruzada

elementos de modalidade cruzada
de dados de mídia social e a CNN
lida com a sequência de tempo

NGBAE [98] Distribuição semântica de modelos Aplicativos de

de texto bilíngue por meio de processamento de
variável latente explicitamente linguagem natural multilíngue,
induzida como incorporações de palavras bilíngues

AE acoplado ao modelo [99] Combina a rede de estado de eco Visualização de dados de séries
com o autoencoder temporais, sequências de valor
real e sequências binárias

Purificação de VAE [100] Projeta um exemplo Mecanismo de defesa para

adversário no manifold de cada purificação de ataques adversários
classe e determina a projeção aplicável em sistemas de vigilância
mais próxima como uma amostra
purificada

6. Conclusão

O aprendizado de representação a partir de dados desempenha um papel crucial para a

implementação bem-sucedida de modelos de aprendizado profundo e ajuda a realizar uma melhor
generalização e alcançar um desempenho aceitável. Autoencoders projetados usando redes neurais
funcionam de maneira excelente para o aprendizado de representação a partir de dados. A proliferação
do aprendizado profundo resultou no amplo uso de autoencoders devido à sua característica inerente
de aprendizado e características de redução de dimensionalidade.
A principal contribuição deste capítulo pode ser enunciada da seguinte forma. Este capítulo
fornece os fundamentos básicos de autoencoders e variantes de última geração de arquiteturas de
autoencoders. A taxonomia gráfica de autoencoders com base em vários fatores necessários para
projetar os autoencoders foi proposta. Este capítulo esclarece o papel das funções de ativação,
profundidade e tamanho da camada da rede neural, estratégias de treinamento e métodos de
regularização para autoencoders. A visão geral resumida de autoencoders com base em características
e aplicações também foi tabulada neste capítulo.

apêndice

A lista de abreviaturas usadas neste capítulo é mencionada na Tabela 2.

Machine Translated by Google

Avaliação de Arquiteturas de Autoencoder … 127

Tabela 2 Lista de abreviaturas

Significado da abreviatura

adagrado Gradiente Adaptativo

Adão Estimativa de Momento Adaptativo
AdvCAE Autoencoder Correlacionado Adversário

SA codificador automático

ARA Autoencoder Adversariamente Regularizado

ARGA Autoencoder de Gráfico Adversariamente Regularizado
ARGVA Gráfico Variacional Adversariamente Regularizado
codificador automático

CAI Autoencoder Contrativo

Autoencoder Convolucional CONV AE

CONV-WTA Convolutional Winner-Take-All Autoencoder

CT Tomografia Computadorizada
DASOM Mapa auto-organizado do autoencoder de remoção de ruído

DIVÃ Codificador Automático Divergente

FC-WTA O Vencedor Leva Tudo Totalmente Conectado

codificador automático

FNN Rede neural de feedforward

GAN Rede Adversária Geradora

GSAE Autoencoder Esparso de Grupo

HSAE Autoencoder esparso regularizado hessiano
HSI Imagem hiperespectral
IWAE Autoencoder ponderado por importância
KL Kullback–Leibler

LDA Alocação de Dirichlet Latente

LSTM Memória de longo prazo

LZW Lempel–Ziv–Welch
mDAE Autoencoder de remoção de ruído marginalizado
ressonância magnética
Imagem de ressonância magnética
MSE Erro quadrático médio
NGBAE Autoencoder bilíngue generativo neural
PCA Análise do componente principal
RAE Autoencoder regularizado
RBM Máquina Boltzmann restrita

ReLUs Unidades lineares retificadas

RN Rede neural recorrente

SAE Autoencoder Esparso

SATAE Saturando Autoencoder

(contínuo)
Machine Translated by Google

128 K. Pawar e VZ Attar

Tabela 2 (continuação)
Significado da abreviatura

SDAE Autoencoder de remoção de ruído empilhado

SELUs Unidades lineares exponenciais escalonadas

SGD Descida do Gradiente Estocástico

Autoencoder SWAE Stacked What-Where

VAE Autoencoder Variacional

WAE Codificador Automático Wasserstein

WTA Autoencoder Winner-Take-All

referências

1. Bengio, Y., Courville, A., Vincent, P.: Aprendizagem de representação: uma revisão e novas perspectivas.
IEEE Trans. Padrão Anal. Mach. Intel. 35, 1798–1828 (2013)
2. Sutskever, I., Vinyals, O., Le, QV: Sequência para sequenciar aprendizagem com redes neurais. Dentro:
Avanços em Sistemas de Processamento de Informação Neural, p. 3104–3112 (2014)
3. Pathak, AR, Pandey, M., Rautaray, S.: Estrutura adaptativa para modelagem de tópicos dinâmicos e temporais
baseados em aprendizado profundo a partir de big data. Pat. recente Eng. 13, 1 (2019). [Link]
2174/1872212113666190329234812
4. Pathak, AR, Pandey, M., Rautaray, S.: Modelo adaptativo para modelagem de tópicos dinâmicos e temporais de big
data usando arquitetura de aprendizado profundo. Int. J. Intel. Sistema Aplicativo. 11(6), 13–27 (MECS-Press)

5. Pathak AR, Pandey M, Rautaray S, Pawar K: Avaliação da detecção de objetos usando redes neurais convolucionais
profundas. In: Bhalla, S., Bhateja, V., Chandavale, AA, Hiwale, AS, Satapathy, SC (eds.) Computação Inteligente e
Informação e Comunicação, pp. 457-466. Springer Singapura (2018)

6. Pathak AR, Pandey M, Rautaray S: Abordagens de aprendizado profundo para detectar objetos a partir de imagens:
uma revisão. In: Pattnaik, PK, Rautaray, SS, Das, H., Nayak, J. (eds.) Progress in Computing, Analytics and
Networking, pp. 491-499. Springer Singapura (2018)
7. Pathak AR, Pandey M, Rautaray S: Aplicação de aprendizado profundo para detecção de objetos.
Prossiga Computação. Sci. 132, 1706–1717 (2018)
8. Pawar, K., Attar, V.: Abordagens de aprendizagem profunda para detecção de atividade anômala baseada em vídeo.
World Wide Web 22, 571–601 (2019)
9. Pawar, K., Attar, V.: Abordagem de Deep Learning para detecção de atividades anormais de
vídeos de vigilância. Em: CCIS. Springer (2019, na imprensa)
10. Khare K, Darekar O, Gupta P, Attar VZ: Previsão de preços de ações de curto prazo usando aprendizado profundo.
In: 2ª Conferência Internacional IEEE sobre Tendências Recentes em Eletrônica, Tecnologia da Informação e
Comunicação (RTEICT), pp. 482–486 (2017)
11. Hinton, GE, Salakhutdinov, RR: Reduzindo a dimensionalidade dos dados com redes neurais.
Ciência 313, 504-507 (2006)
12. Kurtz, KJ: O modelo divergente de autoencoder (DIVA) de aprendizagem de categorias. Psic. Touro.
Rev. 14, 560–576 (2007)
13. Odena, A., Dumoulin, V., Olah, C.: Artefatos de deconvolução e tabuleiro de damas. Destilar (2016). [Link]
10.23915/distill.00003 14. Zhang, Z., et al: Auto-codificador convolucional de subgrafo baseado em profundidade
para representação de rede
Aprendendo. Reconhecimento de padrões. (2019)
15. Cho, K., et al.: Aprendendo representações de frases usando RNN codificador-decodificador para tradução automática
estatística (2014). [Link] 16. Srivastava, N., Mansimov, E., Salakhudinov, R.: Aprendizagem
não supervisionada de representações de vídeo usando LSTMs. In: Conferência Internacional sobre Aprendizado de
Máquina, p. 843–852 (2015)
Machine Translated by Google

Avaliação de Arquiteturas de Autoencoder … 129

17. Goodfellow, I., Bengio, Y., Courville, A.: Deep Learning. Imprensa do MIT (2016)
18. Poultney, C., Chopra, S., Cun, YL, et al.: Aprendizagem eficiente de representações esparsas com um modelo baseado em
energia. In: Avanços em Sistemas de Processamento de Informação Neural, p. 1137–1144 (2007)

19. Lee H, Ekanadham C, Ng AY: Modelo de rede de crença profunda esparsa para área visual V2. In: Avanços em Sistemas
de Processamento de Informação Neural, p. 873–880 (2008)
20. Zou, WY, Ng, AY, Yu, K.: Aprendizagem não supervisionada de invariância visual com coerência temporal. In: Workshop
NIPS 2011 sobre Aprendizado Profundo e Aprendizado de Recursos Não Supervisionado, vol. 3 (2011)

21. Jiang X, Zhang Y, Zhang W, Xiao X: Um novo codificador automático esparso para aprendizado profundo não supervisionado.
Em 2013 Sexta Conferência Internacional sobre Inteligência Computacional Avançada (ICACI), pp. 256–261 (2013)

22. Le, QV, et al.: Construindo recursos de alto nível usando aprendizado não supervisionado em larga escala (2011).
[Link]
23. Chen, J., et al.: Autoencoders regularizados de covariância cruzada para recurso esparso não redundante
representação. Neurocomputação 316, 49-58 (2018)
24. Goroshin, R., LeCun, Y.: Saturating auto-encoders (2013). [Link] 25. Liu W, Ma T, Tao D, You
JHSAE: Auto-codificadores esparsos regularizados de Hesse. Neu
rocomputing 187, 59-65 (2016)
26. Rifai, S., Vincent, P., Muller, X., Glorot, X., Bengio, Y.: Auto-encoders contrativos: invariância explícita durante a extração de
características. In: Proceedings of the 28th International Conference on International Conference on Machine Learning,
pp. 833-840 (2011)
27. Rifai, S., et al.: Auto-encoder contrativo de ordem superior. In: Joint European Conference on Machine Learning and
Knowledge Discovery in Databases, pp. 645–660 (2011)
28. Alain, G., Bengio, Y.: O que os codificadores automáticos regularizados aprendem com a distribuição geradora de dados.
butão. J. Mach. Aprender. Res. 15, 3563–3593 (2014)
29. Mesnil, G., et al.: Desafio de aprendizado não supervisionado e de transferência: uma abordagem de aprendizado profundo.
In: Proceedings of the 2011 International Conference on Unsupervisioned and Transfer Learning Workshop, vol. 27, pág.
97–111 (2011)
30. Konda, K., Memisevic, R., Krueger, D.: Autoencoders de polarização zero e os benefícios da co-adaptação
características (2014). [Link]
31. Makhzani A, Frey B: Autoencoders K-sparse (2013). [Link] 32. Makhzani A, Frey BJ:
Autoencoders do tipo vencedor leva tudo. In: Avanços em Sistemas de Processamento de Informação Neural, p. 2791–2799
(2015)
33. Ng, A.: Autoencoder esparso. CS294A Lecture Notes, vol. 72, pág. 1–19 (2011)
34. Liang K, Chang H, Cui Z, Shan S, Chen X: Aprendizagem de representação com autoencoder suave. In: Conferência
Asiática de Visão Computacional, p. 72–86 (2014)
35. Kampffmeyer M, Løkse S, Bianchi FM, Jenssen R, Livi L: The deep kernelized autoen
codificador. Aplicativo. Computação Suave. 71, 816-825 (2018)
36. Majumdar, A.: Autoencoder estruturado em gráfico. Rede Neural. 106, 271-280 (2018)
37. Sankaran A, Vatsa M, Singh R, Majumdar A: Autoencoder esparso de grupo. ImageVis.
Computar. 60, 64-74 (2017)
38. Vincent P, Larochelle H, Bengio Y, Manzagol P-A: Extraindo e compondo recursos robustos com autoencoders de remoção
de ruído. In: Proceedings of the 25th International Conference on Machine Learning, pp. 1096–1103 (2008)

39. Vincent P, Larochelle H, Lajoie I, Bengio Y, Manzagol P-A: Codificadores automáticos de remoção de ruído empilhados:
aprendendo representações úteis em uma rede profunda com um critério de remoção de ruído local. J.
Mach. Aprender. Res. 11, 3371–3408 (2010)
40. Ferles C, Papanikolaou Y, Naidoo KJ: Denoising autoencoder mapa auto-organizado
(DASOM). Rede Neural. 105, 112–131 (2018)
41. Chen M, Weinberger K, Sha F, Bengio Y: Autoencoders de denoising marginalizados para representações não lineares. In:
Conferência Internacional sobre Aprendizado de Máquina, p. 1476–1484 (2014)
Machine Translated by Google

130 K. Pawar e VZ Attar

42. Maheshwari, S., Majumdar, A.: Autoencoder hierárquico para filtragem colaborativa. In: Conferência Conjunta
Internacional de 2018 sobre Redes Neurais (IJCNN), p. 1–7 (2018)
43. Kingma, DP, Welling, M.: Auto-codificação de bayes variacionais (2013). [Link]
6114
44. Burda, Y., Grosse, R., Salakhutdinov, R.: Autoencoders ponderados por importância (2015). [Link]
1509.00519 45. Makhzani A, Shlens J, Jaitly N, Goodfellow I, Frey B: Adversarial autoencoders (2015).

[Link]
46. Wang X, Peng D, Hu P, Sang Y: Autoencoder correlacionado adversário para não supervisionado
aprendizagem de representação multi-vista. Conhecimento Sistema baseado. (2019)
47. Tolstikhin, I., Bousquet, O., Gelly, S., Schoelkopf, B.: Autoencoders Wasserstein (2017).
[Link]
48. Kim Y, Zhang K, Rush AM, LeCun Y, et al: Adversarially regularized autoencoders (2017). [Link]
1706.04223 49. Yan X, Chang H, Shan S, Chen X: Modelagem de dinâmica de vídeo com dynencoder profundo.
Dentro:
Conferência Europeia sobre Visão Computacional, p. 215–230 (2014)
50. Zhao J, Mathieu M, Goroshin R, Lecun Y: Auto-encoders empilhados o que onde (2015).
[Link]
51. LeCun, Y., Bottou, L., Bengio, Y., Haffner, P., et al.: Aprendizagem baseada em gradiente aplicada ao
reconhecimento de documentos. proc. IEEE 86, 2278-2324 (1998)
52. Zeiler MD, Krishnan D, Taylor GW, Fergus R: Redes deconvolucionais. In: Conferência sobre Visão Computacional
e Reconhecimento de Padrões, pp. 2528-2535. IEEE (2010)
53. Robbins, H., Monro, S.: Um método de aproximação estocástica. Ana Matemática. Stat., 400-407
(1951)
54. Kingma, DP, Ba, J.: Adam: um método para otimização estocástica (2014). [Link]
1412.6980
55. Duchi, J., Hazan, E., Singer, Y.: Métodos de subgradiente adaptativo para aprendizagem online e stochas
otimização de carrapatos. J. Mach. Aprender. Res. 12, 2121–2159 (2011)
56. Le, QV, et al.: Sobre métodos de otimização para aprendizado profundo. In: Proceedings of the 28th International
Conference on International Conference on Machine Learning, pp. 265–272 (2011)

57. Rumelhart, DE, Hinton, GE, Williams, RJ, et al.: Representações de aprendizagem por erros de retropropagação.
Cognição Modelo. 5, 1 (1988)
58. Hinton GE, McClelland JL: Aprendendo representações por recirculação. Em: Informações Neurais
Sistemas de Processamento de Informação, pp. 358–366 (1988)
59. Zhou Y, Arpit D, Nwogu I, Govindaraju V: O treinamento conjunto é melhor para auto-codificadores profundos?
(2014). [Link] 60. Qi Y, Wang Y, Zheng X, Wu Z: Aprendizado robusto de recursos por
autoencoder empilhado com critério de correntropia máxima. In: 2014 IEEE International Conference on Acoustics,
Speech and Signal Processing (ICASSP), pp. 6716–6720 (2014)

61. Kukaÿcka, J., Golkov, V., Cremers, D.: Regularização para aprendizado profundo: uma taxonomia (2017).
[Link]
62. Lamb, A., Dumoulin, V., Courville, A.: Regularização discriminativa para modelos generativos (2016). http://
[Link]/abs/1602.03220 63. Kamyshanska, H., Memisevic, R.: A energia potencial de um autoencoder. IEEE
Trans. Padrão Anal. Mach. Intel. 37, 1261-1273 (2015)

64. Kamyshanska, H., Memisevic, R.: Sobre a pontuação do autoencoder. In: Conferência Internacional sobre
Aprendizado de Máquina, p. 720–728 (2013)
65. Krogh A, Hertz JA: Um simples decaimento de peso pode melhorar a generalização. In: Avanços em
Sistemas de Processamento de Informação Neural, p. 950-957 (1992)
66. Fan, YJ: Saliência do nó do Autoencoder: selecionando representações latentes relevantes. Escolha de padrão
nit. 88, 643-653 (2019)
67. LeCun YA, Bottou L, Orr GB, Müller K-R: Backprop eficiente. In: Redes Neurais: Truques do Comércio, pp 9–48.
Springers (2012)
Machine Translated by Google

Avaliação de Arquiteturas de Autoencoder … 131

68. Klambauer G, Unterthiner T, Mayr A, Hochreiter S: Redes neurais auto-normalizantes.

In: Avanços em Sistemas de Processamento de Informação Neural, p. 971-980 (2017)
69. Leonard, M.: Curso Deep Learning Nanodegree Foundation. Notas de Aula em Autoencoders.
Udacidade (2018)
70. Xiong, Y., Zuo, R.: Reconhecimento de anomalias geoquímicas usando uma rede de autoencoder profunda.
Computar. Geosci. 86, 75-82 (2016)
71. Leng B, Guo S, Zhang X, Xiong Z: recuperação de objetos 3D com convolucional local empilhado
codificador automático. Próximo Processo. 112, 119–128 (2015)
72. Ribeiro, M., Lazzaretti, AE, Lopes, HS: Um estudo de auto-codificadores convolucionais profundos para
detecção anormal em vídeos. Reconhecimento de padrões. Lett. 105, 13–22 (2018)
73. Li L, Li X, Yang Y, Dong J: Análise de similaridade de dados de trajetória de rastreamento interno com um autoencoder
convolucional profundo. Sustentar. Cidades Soc. 45, 588–595 (2019)
74. X Wan, C Zhao, Y Wang, W Liu: Autoencoder esparso empilhado na classificação de dados hiperespectrais usando estatísticas
espectral-espaciais, estatísticas de ordem superior e recursos de espectro multifractal.
Infravermelho Phys. Technol. 86, 77-89 (2017)
75. McCoy JT, Kroon S, Auret L: Autoencoders Variacionais para imputação de dados perdidos com aplicação a um circuito de
fresamento simulado. Documentos da IFAC OnLine 51, 141–146 (2018)
76. Wu, C., et al.: Análise de sentimento dimensional semi-supervisionada com autoencoder variacional.
Conhecimento Sistema baseado. 165, 30-39 (2019)
77. Zhang J, Shan S, Kan M, Chen X: Redes de autoencoder grosseiro a fino (CFAN) para alinhamento de face em tempo real.
In: Conferência Europeia sobre Visão Computacional, p. 1–16 (2014)
78. Masci J, Meier U, Cirecsan D, Schmidhuber J: Auto-encoders convolucionais empilhados para extração de recursos
hierárquicos. In: Conferência Internacional sobre Redes Neurais Artificiais, p. 52–59 (2011)

79. Liou C-Y, Cheng W-C, Liou J-W, Liou D-R: Autoencoder para palavras. Neurocomputação 139, 84-96 (2014)

80. Carreira-Perpinan, MA, Raziperchikolaei, R.: Hashing com autoencoders binários. In: The IEEE Conference on Computer
Vision and Pattern Recognition (CVPR) (2015)
81. Pan, S., et al.: Autoencoder de gráfico adversariamente regularizado para incorporação de gráfico (2018).
[Link]
82. Li, M., et al.: GRAINS: autoencoders recursivos generativos para cenas INdoor. ACM Trans.
Gráfico. 38, 12:1–12:16 (2019)
83. Alaverdyan, Z., Chai, J., Lartizien, C.: Aprendizado de recursos não supervisionado para detecção de valores discrepantes
com autoencoders convolucionais empilhados, redes siamesas e autoencoders wasserstein: aplicação à detecção de
epilepsia. In: Deep Learning em Análise de Imagens Médicas e Aprendizagem Multimodal para Apoio à Decisão Clínica,
pp. 210-217. Springers (2018)
84. Hou, L., et al.: Autoencoder esparso para detecção e representação de núcleo não supervisionado em
imagens de histopatologia. Reconhecimento de padrões. 86, 188–200 (2019)
85. Ullah, A., Muhammad, K., Haq, IU, Baik, SW: Reconhecimento de ação usando codificador automático profundo otimizado e
CNN para fluxos de dados de vigilância de ambientes não estacionários. Futuro.
gerar Computar. Sistema (2019)
86. Zhao C, Zhang L: Autoencoders empilhados espectrais-espaciais baseados em decomposição de matrizes esparsas e de
baixo nível para detecção de anomalias hiperespectrais. Infravermelho Phys. Technol. 92, 166-176 (2018)

87. Singh M, Nagpal S, Vatsa M, Singh R: Você é elegível? Previsão da idade adulta a partir de imagens de rosto por meio do
autoencoder médio específico da classe. Reconhecimento de padrões. Lett. 119, 121-130 (2019)
88. Tasnim, S., Rahman, A., Oo, AMT, Haque, ME: Autoencoder para previsão de energia eólica.
Vento Renováveis. Água Dom. 4, 6 (2017)
89. Lv, S.-X., Peng, L., Wang, L.: Autoencoder empilhado com regressão de eco-estado para previsão de demanda de turismo
usando dados de consulta de pesquisa. Aplicativo. Computação Suave. 73, 119-133 (2018)
90. Xie R, Wen J, Quitadamo A, Cheng J, Shi X: Um modelo de auto-codificador profundo para gene
expressãopredição. BMC Genom. 18.845 (2017)
91. Zhang J, Li K, Liang Y, Li N: Aprendendo rostos 3D a partir de imagens 2D por meio de contração empilhada
codificador automático. Neurocomputação 257, 67-78 (2017)
Machine Translated by Google

132 K. Pawar e VZ Attar

92. Gareis IE, Vignolo LD, Spies RD, Rufiner HL: Coherent averaging estimation autoen coders aplicados ao
processamento de potenciais evocados. Neurocomputação 240, 47-58 (2017)
93. Mehta J, Majumdar A: RODEO: robusto autoencoder DE-aliasing para reconstrução de imagens médicas em tempo
real. Reconhecimento de padrões. 63, 499-510 (2017)
94. Liu, Y., Feng, X., Zhou, Z.: Classificação de vídeo multimodal com codificadores autoen contrativos empilhados.
Próximo Processo. 120, 761-766 (2016)
95. Zhang, Z., et al.: Recurso de gargalo baseado em rede neural profunda e dereverberação baseada em autoencoder
de denoising para identificação de alto-falante distante. EURASIP J. Processo de música de fala de áudio. 2015,
12 (2015)
96. Makkie M, Huang H, Zhao Y, Vasilakos AV, Liu T: Autoencoder convolucional profundo distribuído rápido e escalável
para análise de big data de fMRI. Neurocomputação 325, 20-30 (2019)
97. Guo, Q., et al.: Aprendendo recursos uniformes robustos para dados sociais de mídia cruzada usando
codificadores automáticos. Conhecimento Sistema baseado. 102, 64-75 (2016)
98. Su, J., et al.: Um autocodificador generativo neural para incorporações de palavras bilíngues. Inf. Sci. (Nova Iorque)
424, 287-300 (2018)
99. Gianniotis N, Kügler SD, Tino P, Polsterer KL: Autoencoder acoplado ao modelo para visualização de séries
temporais. Neurocomputação 192, 139-146 (2016)
100. Hwang U, Park J, Jang H, Yoon S, Cho NI: PuVAE: um autoencoder variacional para purificar
exemplos adversários (2019). [Link]
Machine Translated by Google

O Encoder-Decoder Framework
e suas aplicações

Ahmad Asadi e Reza Safabakhsh

Resumo A estrutura do codificador-decodificador neural avançou significativamente no estado da

arte em tradução automática. Muitos pesquisadores nos últimos anos empregaram os modelos
baseados em codificador-decodificador para resolver tarefas sofisticadas, como legendagem de
imagens/vídeos, resposta a perguntas textuais/visuais e resumo de texto. Neste trabalho estudamos
o framework codificador-decodificador de linha de base em tradução automática e damos uma breve
olhada nas estruturas de codificador propostas para lidar com as dificuldades de extração de recursos.
Além disso, é fornecido um estudo empírico de soluções para permitir que os decodificadores gerem
sentenças de saída mais ricas e refinadas. Finalmente, estuda-se o mecanismo de atenção que é
uma técnica para lidar com dependências de longo prazo e melhorar o desempenho do codificador-
decodificador em tarefas sofisticadas.

Palavras -chave Estrutura codificador-decodificador · Tradução automática ·

Legendagem de imagem · Geração de legenda de vídeo · Resposta a perguntas ·
Dependências de longo prazo · Mecanismo de atenção

1. Introdução

A solução para um número considerável de problemas que precisamos resolver se enquadra na

categoria de métodos baseados em codificador-decodificador. Podemos desejar projetar redes
extremamente complexas para enfrentar desafios sofisticados, como descrever automaticamente
uma imagem arbitrária ou traduzir uma frase de um idioma para outro. A estrutura do codificador-
decodificador neural foi recentemente explorada para resolver uma ampla variedade de desafios no
processamento de linguagem natural, visão computacional, processamento de fala e até problemas
interdisciplinares. Alguns exemplos de problemas que podem ser resolvidos pelos modelos baseados
em codificador-decodificador são tradução automática, imagem automática e

A. Asadi · R. Safabakhsh (B)

Departamento de Engenharia da Computação e Tecnologia da Informação, Amirkabir
University of Technology, Teerã, Irã e-mail: safa@[Link]

A. Asadi
e-mail: [Link]@[Link]

© Springer Nature Switzerland AG 2020 133

W. Pedrycz e S.-M. Chen (eds.), Deep Learning: Concepts and
Architectures, Studies in Computational Intelligence 866, https://
[Link]/10.1007/978-3-030-31756-0_5
Machine Translated by Google

134 A. Asadi e R. Safabakhsh

geração de legendas de vídeo, resposta a perguntas textuais e visuais e conversão de áudio para texto.

A parte do codificador neste modelo é uma estrutura neural que mapeia entradas brutas para um
espaço de recursos e passa o vetor de recursos extraído para o decodificador. O decodificador é outra
estrutura neural que processa o vetor de recursos extraído para tomar decisões ou gerar saídas
apropriadas para o problema.
Uma grande variedade de codificadores é proposta para codificar diferentes tipos de entradas.
Com redes neurais volucionais (CNNs) são normalmente usadas na codificação de entradas de
imagem e vídeo. Redes neurais recorrentes (RNNs) são amplamente utilizadas como codificadores
onde a entrada é uma sequência de dados estruturados ou sentenças. Além disso, estruturas mais
complexas de diferentes redes neurais têm sido usadas para modelar complexidades nas entradas.
Estruturas hierárquicas CNN-RNN são exemplos de combinações neurais que são amplamente
utilizadas para representar dependências temporais em vídeos que são usados na geração de
descrição de vídeo.
Outro problema potencial com essa abordagem codificador-decodificador de linha de base é que o
codificador precisa compactar todas as informações necessárias da entrada em um tensor de tamanho
fixo. Isso pode tornar difícil para a rede neural modelar dependências temporais tanto na entrada
quanto na saída. O mecanismo de atenção é introduzido para superar o problema da extração de
características de comprimento fixo como uma extensão do modelo codificador-decodificador. A
característica distintiva desta abordagem do codificador-decodificador de linha de base é que ele não
tenta codificar uma entrada inteira em um único tensor de tamanho fixo. Em vez disso, ele codifica a
entrada em uma sequência de vetores de anotação e seleciona uma combinação desses vetores de
forma adaptativa, enquanto decodifica e gera a saída em cada etapa.

Algumas das tarefas em que o modelo codificador-decodificador é usado para resolver o problema
são as seguintes.

1.1 Tradução automática

A “tradução automática” (MT) é a tarefa de gerar uma frase em um idioma de destino que tenha o
mesmo significado que a frase dada de um idioma de origem.
Existem duas abordagens diferentes na tradução automática.
A primeira abordagem, chamada de “tradução automática estatística” (SMT), é caracterizada pelo
uso de técnicas de aprendizado de máquina estatística para traduzir automaticamente a frase do
idioma de origem para o idioma de destino. Em menos de duas décadas, a SMT passou a dominar a
pesquisa acadêmica de tradução automática [1].
A segunda abordagem é chamada de “Tradução de Máquina Neural” (NMT). Nesta categoria, o
framework codificador-decodificador foi proposto pela primeira vez por Cho et al. [2] em 2014. No
modelo proposto por Cho et al. [2] uma rede neural é usada para extrair características da sentença
de entrada e outra rede neural é usada para gerar uma sentença palavra por palavra do idioma de
destino usando o vetor de características extraído.
Machine Translated by Google

O Encoder-Decoder Framework e suas aplicações 135

Nas estruturas neurais usadas na NMT, uma rede neural é treinada para mapear a sequência de
entrada (a sentença de entrada como uma sequência de palavras) para a sequência de saída. Este tipo
de aprendizagem é conhecido como “Aprendizagem de Sequência a Sequência”.
Avaliações nos primeiros modelos de NMT mostraram que, embora as traduções geradas estejam
corretas, o modelo enfrenta problemas extremos ao traduzir frases longas [3]. O problema de modelagem
de “dependências de longo prazo” é um dos desafios mais importantes nos modelos de codificador-
decodificador. Vamos detalhar isso e dar uma olhada nas soluções propostas, mais adiante neste
capítulo.

1.2 Legendagem de imagem/ vídeo

Legendagem de imagem e legendagem de vídeo são os problemas de associar uma descrição textual
a uma determinada imagem ou vídeo que descreve holisticamente os objetos e eventos apresentados
na entrada. Uma grande variedade de abordagens tem sido proposta para resolver esses problemas,
incluindo modelos gráficos probabilísticos (PGMs) e modelos baseados em codificadores-decodificadores
neurais.
Modelos baseados em codificador-decodificador para legendagem de imagens usam uma CNN
como codificador para extrair um vetor de características da imagem de entrada e passá-lo para um
RNN como o decodificador para gerar a legenda. A arquitetura do modelo nesta tarefa é a mesma da
tradução automática, exceto que o codificador usa uma CNN para codificar a imagem em vez de uma
RNN.
Na legendagem de vídeo, também chamada de “geração de descrição de vídeo”, um modelo
semelhante baseado na arquitetura codificador-decodificador é empregado para gerar uma legenda
para o vídeo de entrada. Nos modelos de legendagem de vídeo, o codificador normalmente consiste
em CNNs ou combinação de CNNs e RNNs para codificar o vídeo de entrada e o decodificador é o
mesmo que o decodificador na tradução automática e legendagem de imagens.

1.3 Resposta de perguntas textuais/ visuais

As respostas de perguntas textuais e visuais são os problemas de gerar uma resposta para uma
determinada pergunta sobre um artigo e sobre uma imagem de entrada, respectivamente. Os modelos
propostos para resolver esses problemas devem gerar uma resposta curta ou longa, dado um artigo ou
uma imagem, e uma pergunta sobre ele como entrada. A arquitetura do modelo básico é então
semelhante à da tradução automática, exceto que o codificador é necessário para extrair um vetor de
recursos para um par de entradas. O decodificador é o mesmo que o decodificador em tradução
automática e legendagem de imagem/vídeo porque deve gerar uma frase descrevendo o significado do
vetor de recursos gerado pelo codificador.
Machine Translated by Google

136 A. Asadi e R. Safabakhsh

1.4 Resumo de Texto

Os modelos propostos para resumir um texto devem gerar um resumo textual para o texto de entrada.
A única restrição na saída é que ela deve descrever o mesmo significado que o texto de entrada e
seu comprimento deve ser menor que o da entrada.
A arquitetura base desses modelos é a mesma da arquitetura proposta na tradução automática,
exceto que a saída gerada aqui é do mesmo idioma da entrada.

Pode-se ver facilmente que a arquitetura de linha de base proposta na tradução automática
também é utilizada em outras tarefas com pequenas alterações. Além disso, os decodificadores dos
modelos em diferentes tarefas são semelhantes, pois a maioria deles é usada para gerar uma frase
palavra por palavra para descrever o significado da entrada representada pelo vetor de características.
Por outro lado, uma grande variedade de codificadores é usada para extrair vetores de características
apropriados dependendo dos tipos de entrada em diferentes tarefas.
A próxima seção deste capítulo discute o modelo codificador-decodificador de linha de base.
O primeiro modelo baseado em codificador-decodificador proposto em tradução automática é
apresentado na Seção 3. A Seção 4, discute os diferentes tipos de codificadores e suas aplicações
em detalhes e faz uma perspectiva geral das estruturas dos codificadores em diferentes problemas.
A Seção 5 fornece um estudo abrangente das estruturas do decodificador, técnicas de fabricação de
decodificadores mais profundos, juntamente com suas aplicações na geração de legendas de
imagem/vídeo. A Seção 6 apresenta o mecanismo de atenção e seu uso na tradução automática,
seguido de um estudo empírico do mecanismo de atenção em outros problemas.

2 Modelo de Codificador-Decodificador de Linha de Base

Nesta seção, apresentamos o modelo codificador-decodificador muito básico. Para dar uma ideia
clara da ideia, é apresentada a estrutura básica para resolver a tarefa de tradução automática na
qual o modelo é projetado para traduzir uma frase de um idioma de origem para um de destino.

2.1 Histórico

Uma ampla gama de problemas em processamento de linguagem natural, visão computacional,

reconhecimento de fala e alguns problemas multidisciplinares são resolvidos por modelos baseados
em codificador-decodificador. Mais especificamente, alguns problemas sofisticados em que se deseja
gerar uma saída frequentemente sequencial, como texto, podem ser resolvidos por modelos
baseados na estrutura codificador-decodificador.
A ideia principal por trás do framework é que o processo de geração de saída pode ser dividido
em dois subprocessos da seguinte forma:
Machine Translated by Google

O Encoder-Decoder Framework e suas aplicações 137

Fig. 1 O esquema básico do modelo codificador-decodificador

Fase de codificação: Uma determinada entrada é primeiramente projetada em outro espaço por
uma função de projeção, chamada “encoder”, a fim de fornecer uma “boa representação” da entrada.
O codificador também pode ser visto como um extrator de recursos da entrada e o processo de
projeção pode ser expresso por um processo de extração de recursos.

Fase de decodificação: Após a fase de codificação, um “vetor latente” é gerado para a entrada
dada que representa bem o seu significado. Na segunda fase, outra função de projeção, chamada
“decodificador”, é necessária para mapear o vetor latente para o espaço de saída.
A Figura 1 demonstra o esquema básico da estrutura codificador-decodificador. Seja X = {X0,
X1,..., Xn} as entradas e Y = {Y0, Y1,..., Ym} as saídas do problema. O decodificador extrai um
vetor de características da entrada e o passa para o decodificador. O decodificador então gera a
saída com base nos recursos extraídos pelo codificador.

2.2 O Modelo Codificador-Decodificador para Tradução Automática

A tradução automática é o problema em que os modelos baseados em codificador-decodificador

foram originados e propostos primeiro. Os conceitos básicos desses modelos são moldados e
apresentados na literatura de tradução automática. Nesta seção apresentamos a estrutura básica
codificador-decodificador proposta para tradução automática por Cho et al. [2] para esclarecer o
modelo e seus fundamentos.

2.3 Formulação

Tanto a entrada quanto a saída dos modelos de tradução automática são frases que podem ser
formuladas como uma sequência de palavras. Seja X = {X0, X1,..., XLi} denotar a sentença de
entrada, onde xi é a iésima palavra nela, supondo que a sentença de entrada tenha Li
Machine Translated by Google

138 A. Asadi e R. Safabakhsh

Fig. 2 Um vetor para cada

palavra em um dicionário de
amostra. As frases também
podem ser modeladas usando a
técnica Bag of Words (BoW) em
que a presença de uma palavra
na frase é considerada sem
qualquer informação sobre a
ordem das palavras

palavras. Da mesma forma, a sentença de saída pode ser formulada como Y = {y0, y1,..., yLo} em
que yi é a i- ésima palavra na sentença de saída supondo que ela tenha Lo palavras.
Além disso, todos os Xis e yi s são vetores one-hot criados a partir de um dicionário de todas as
palavras nos conjuntos de dados de entrada e saída.
Um vetor one-hot é um vetor cujos componentes são todos zero, exceto por um deles.
Para criar um vetor one-hot para cada palavra, primeiro é criado um dicionário1 de todas as
palavras possíveis nos conjuntos de dados disponíveis. Assumindo N palavras no dicionário, um
vetor zero dimensional N para cada palavra é criado e o componente com o mesmo índice que a
palavra no dicionário é definido como 1. A Figura 2 demonstra o vetor one-hot para cada palavra
em um dicionário de amostra . Supondo que o dicionário D tenha 5 palavras “I”, “cat”, “dog”, “have”,
“a” sequencialmente com os índices 0–4, o vetor one-hot para cada palavra é exibido na figura.

O processo de tradução é dividido nos dois subprocessos a seguir.

2.3.1 Fase de Codificação em MT

Um RNN é usado para extrair um vetor de recursos da sentença de entrada do idioma de origem.
Todas as palavras na sentença de entrada são convertidas em vetores one-hot e passadas para o
RNN na ordem de sua presença na sentença. O RNN então atualiza seu estado oculto e vetores
de saída de acordo com cada palavra. A iteração é interrompida quando o token End of Sentence
(EOS) é passado para o RNN. O token EOS é um token adicionado manualmente ao final das
frases de entrada para especificar o ponto final da frase. O estado oculto do RNN após o token
EOS é então usado como o vetor de recursos da sentença de entrada. Os vetores one-hot das
palavras na frase de entrada são criados usando o dicionário de palavras do idioma de origem.

1Um dicionário é uma lista de palavras únicas com índices únicos.

Machine Translated by Google

O Encoder-Decoder Framework e suas aplicações 139

2.3.2 Fase de decodificação em MT

Outra RNN é usada para gerar as palavras da sentença de saída em uma ordem apropriada. O
decodificador RNN é projetado para prever uma distribuição de probabilidade sobre todas as palavras
possíveis no dicionário das palavras do idioma de origem em cada etapa. Em seguida, uma palavra é
selecionada em relação à distribuição de probabilidade produzida como a próxima palavra na frase. A
iteração é interrompida quando o token EOS é gerado pelo decodificador ou um número predefinido
de palavras é gerado.
A estrutura do modelo proposto por Cho et al. [2] é mostrado na Fig. 3. O vetor de contexto
extraído pelo codificador é denotado por C, que é o estado oculto do codificador RNN na última etapa.

2.4 Codificadores em Tradução Automática (Extração de Recurso)

Um RNN é usado como codificador no modelo proposto por Cho et al. [2] Deixe ele denotar o estado
oculto do codificador RNN. Este vetor de estado é atualizado a cada passo de tempo t de acordo com
a Eq. (1) em que ht é o estado oculto do codificador
e ativação não
no passo
linear de
quetempo
pode t,ser
fencoder
tão simples
é umaquanto
funçãouma
de
função sigmóide logística elementar e tão complexa quanto uma Long Short-Term Memory (LSTM) ,
e Xt é o vetor one-hot da t- ésima palavra na sentença de entrada.

hte = fencoder htÿ1

e , xt (1)

Fig. 3 Uma ilustração do primeiro modelo baseado em codificador-decodificador proposto para tradução automática
Machine Translated by Google

140 A. Asadi e R. Safabakhsh

Supondo que a sentença de entrada tenha palavras Li, o codificador RNN deve iterar em
cada palavra e atualizar seu vetor de estado oculto em cada etapa. O estado oculto do RNN
após a palavra Lith é então passado para o decodificador como o vetor de contexto C. Assim,
o vetor de contexto extraído pelo codificador pode ser calculado como na Eq. (dois).

C = hLi (dois)
e

2.5 Decodificadores em Tradução Automática (Modelagem de Linguagem)

O decodificador deve gerar a frase de saída palavra por palavra de forma que o significado
da frase seja o mesmo que o significado da frase de entrada representada pelo vetor de
contexto C. De outro ponto de vista, o decodificador pode ser visto como um RNN que
maximiza a probabilidade da sentença traduzida no conjunto de dados para a sentença de
entrada e seu vetor de contexto gerado conforme expresso em (3), em que ÿ é o conjunto de
todos os pesos treináveis e os parâmetros do modelo.

Prÿ {Y |X} (3)

Por outro lado, de acordo com a estrutura codificador-decodificador, a variável aleatória C

depende diretamente da variável aleatória X, e a variável aleatória Y depende diretamente da
variável aleatória C. A Figura 4 mostra o gráfico de dependência entre essas 3 variáveis
aleatórias.
A variável C é uma “variável latente”, pois não é observada diretamente, mas é inferida
pelo modelo (especificamente pelo codificador). De acordo com as dependências apresentadas
na Fig. 4 e considerando o fato de que a variável aleatória Y depende diretamente da variável
latente C, o procedimento de treinamento dos decodificadores pode ser separado do
procedimento de treinamento dos codificadores. Em outras palavras, como C é dado durante
o treinamento dos decodificadores, podemos substituir a verossimilhança expressa em (3)
pela verossimilhança expressa em (4). Além disso, assumindo que cada palavra na sentença
depende apenas do significado das palavras anteriores na sentença, a probabilidade de uma
sentença pode ser substituída pela multiplicação das probabilidades de suas palavras dada a
uns.

Isto
Prÿ {Y |C} = ÿ t=0Pr{yt|ytÿ1, ytÿ2,..., y0,C} (4)

Fig. 4 Gráfico acíclico dirigido de dependências de variáveis aleatórias no modelo codificador-decodificador

Machine Translated by Google

O Encoder-Decoder Framework e suas aplicações 141

De acordo com a Eq. (4) o procedimento de treinamento dos modelos baseados em codificador-
decodificador pode ser dividido em dois sub-procedimentos. Primeiro, o codificador é treinado para
extrair o vetor de características apropriado da entrada. Então, o decodificador é treinado para gerar
a saída apropriada dado o vetor de características extraído pelo codificador treinado.
No entanto, usando a Eq. (4) permite que o codificador e as partes do decodificador sejam treinados de
forma independente, eles podem ser treinados conjuntamente e de maneira ponta a ponta [2, 4, 5].
Outra consequência do uso da Eq. (4) é que o decodificador deve gerar uma distribuição de
probabilidade sobre cada palavra em cada etapa t dadas suas palavras previamente geradas e o
vetor de contexto extraído pelo codificador. A distribuição de probabilidade pode ser formulada pelo
RNN de acordo com as Eqs. (5) e (6). Seja ht o estado oculto do decodificador no passo de tempo t.d
Seja Ot a saída do decodificador no passo de tempo t (um vetor dimensional Lo ) que é gerado por
uma função não linear g aplicada no estado oculto do decodificador e no vetor de contexto C. O
estado oculto do decodificador também é gerado pela função não linear fdecoder aplicada em a
palavra gerada anteriormente, o estado oculto do decodificador no passo de tempo anterior e o vetor
de contexto de acordo com (7). Com a aplicação de um Softmax na saída, é gerado um vetor de
mesmo tamanho cuja soma de componentes é igual a um e pode ser tratada como a distribuição de
probabilidade desejada.

Ot = g ht d , ytÿ1,C (5)

Pr{yt|ytÿ1, ytÿ2,..., y0,C} = Sof tMax(Ot ) (6)

htd = fdecodificador
htÿ1 d , ytÿ1,C (7)

A cada passo de tempo, a distribuição de probabilidade Pr yt |ytÿ1, ytÿ2,..., y0,C é gerada pelo
decodificador de acordo com a Eq. (6) e a próxima palavra é selecionada em relação a essa
distribuição de probabilidade sobre as palavras no dicionário do idioma de destino.

Os dois componentes do modelo proposto podem ser treinados em conjunto para minimizar a
verossimilhança condicional negativa expressa em (8) em que N é o número de amostras no conjunto
de dados, Yn e Xn são o enésimo par de saída e entrada no conjunto de dados, ÿ é o conjunto de
todos os parâmetros treináveis e Loss é a função de perda a ser minimizada.

Perda = - 1ÿN _
n=0 log Prÿ (Yn|Xn) (8)
N

3 Variedades de Estrutura de Codificador

A arquitetura do codificador-decodificador de linha de base proposta por Cho et al. [2] em tradução
automática atraiu a atenção de muitos pesquisadores em diferentes áreas. Como explicado
anteriormente, quase todas as variantes da arquitetura de linha de base em diferentes tarefas compartilham uma
Machine Translated by Google

142 A. Asadi e R. Safabakhsh

decodificador semelhante, mas a estrutura do codificador varia de acordo com o tipo de entrada.
Nesta seção, apresentaremos as estruturas importantes de codificadores para codificar diferentes
tipos de entrada.

3.1 Sentença como Entrada

O codificador mais simples para problemas com sentenças como entradas é um RNN. O primeiro
codificador proposto na tradução automática é um LSTM que pega todas as palavras da sentença
de entrada, as processa e retorna o vetor de estado oculto como o vetor de contexto.

Juntamente com as RNNs, as CNNs são empregadas para extrair características das sentenças
de origem na fase de codificação. Como exemplo, Gehring et al. propôs um codificador convolucional
para tradução automática a fim de criar melhores vetores de contexto levando em consideração
palavras próximas usando uma CNN [6]. Neste codificador, uma CNN com um tamanho de kernel
de k = 3 é usada para extrair uma combinação do significado de cada três palavras próximas na
sentença para gerar o vetor de contexto.
Além disso, diferentes células RNN são usadas como blocos do codificador para entradas de
sentenças. Os LSTMs [7] são amplamente utilizados devido à sua capacidade de lidar com
dependências de longo prazo e lembrar o histórico distante na sequência de entrada [5, 8-10]. O
GRU [2] também é utilizado em diferentes modelos propostos devido ao seu bom desempenho e
ao fato de poder ser assumido como uma versão leve do LSTM [2, 11–13].
Os modelos propostos por Cho et al. [2] (RNNenc), Cho et al. [3] (grConv), Sutskever et al. [5]
(Moisés), Bahdanau et al. [8] (RNNsearch) são avaliados em uma tarefa de tradução de inglês para
francês e os resultados são relatados na Tabela 1. A pontuação BLEU [14] é usada para avaliar os
modelos de tradução automática.
O modelo RNNenc (proposto por Cho et al. [2]) usa a estrutura RNN proposta para codificar a
sentença de entrada enquanto o modelo grConv (proposto por Cho et al. [3]) emprega uma rede
convolucional recorrente fechada como o codificador e o Moses O modelo (proposto por Krishevski
[15]) usa células LSTM como codificador. Ambos os dois primeiros modelos usam unidades
recorrentes fechadas como decodificador, enquanto o terceiro usa as células LSTM como
decodificador.
De acordo com os resultados relatados, o modelo Moses supera os anteriores devido ao uso
de células LSTM que podem lidar com o problema de extração de dependências de longo prazo.
Além disso, os resultados relatados por Cho et al. [2] mostrar que

Tabela 1 Pontuações BLEU

Modelo Pontuação BLEU de Pontuação do teste BLEU
computadas nos conjuntos de
treinamento
treinamento e teste
RNNenc 21.01 23,45

grConv 17.09 18.22

Moisés 32,77 35,63

Pesquisa RNN - 36,15

Machine Translated by Google

O Encoder-Decoder Framework e suas aplicações 143

o desempenho do modelo diminui muito com o aumento do comprimento das sentenças. Assim, o
principal problema com os codificadores e os decodificadores nas tarefas de tradução automática
é extrair dependências de longo prazo. O modelo RNNsearch (proposto por Bahdanau et al. [8])
propôs uma nova técnica para lidar com dependências de longo prazo chamada “mecanismo de
atenção” que será introduzida posteriormente neste artigo.
Também discutiremos o desafio das “dependências de longo prazo” mais adiante na Seção 4.1.

3.2 Imagem como entrada

Arquiteturas baseadas em codificador-decodificador formam a maioria dos modelos propostos para

gerar legendas para imagens. Nesses modelos, o processo de geração de legendas para a imagem
de entrada é dividido em duas etapas. A primeira etapa é a codificação na qual um vetor de
características extraído da imagem é retornado como o vetor de contexto. A segunda etapa é a
decodificação na qual o vetor de contexto gerado é passado para um decodificador para gerar
sentenças que descrevem o contexto.
A melhor escolha para codificadores em tais problemas é uma CNN. Quase todos os modelos
propostos para legendagem de imagens baseados no framework codificador-decodificador utilizam
diferentes tipos de CNNs como codificadores. Abordagens baseadas em codificador-decodificador
neural para legendagem de imagens compartilham a mesma estrutura para decodificador, enquanto
na maioria deles o codificador consiste em uma única CNN. Assim, o vetor de características
extraído da imagem pode ser expresso na Eq. (9) em que X é a imagem de entrada, CNN(X) é a
saída da rede CNN e C é o vetor de contexto passado para o decodificador.

C = CNN(X) (9)

Uma grande variedade de CNNs é empregada como codificadora nos modelos propostos para
legendagem de imagens. Uma vez que as versões pré-treinadas de VGGNet [16] e AlexNet [15] no
conjunto de dados ImageNet [17] extraem boas características de imagens para diferentes tarefas
e estão disponíveis online, elas têm sido usadas como codificadores em diferentes modelos de
legendagem de imagens propostos [18–20 ]. Além disso, ResNet [21] tem sido amplamente
utilizado devido ao seu bom desempenho como encoder em tais modelos [22–24]. O Google NIC
Inception v3 [25] também foi usado em modelos propostos devido à sua melhor precisão de
classificação de imagem em comparação com o ResNet [26–29]. Yao et ai. [30] integrou LSTMs
baseados em atributos (LSTM-A) com as CNNs e os treinou de uma maneira ponta a ponta para
impulsionar o codificador.
A Figura 5 ilustra o uso de CNNs como codificador em modelos baseados no framework
codificador decodificador para legendagem de imagens proposto por Vinyals et al. [28] Arquiteturas
semelhantes são usadas para gerar legendas em outros estudos. Como é mostrado na figura, a
parte codificadora do modelo consiste em uma CNN extraindo um vetor de características da
imagem de entrada. O vetor de recursos extraído é então passado para o decodificador para gerar
a legenda apropriada. O decodificador consiste em um RNN que gera a probabilidade da próxima
palavra de acordo com (4) em cada etapa.
Machine Translated by Google

144 A. Asadi e R. Safabakhsh

Fig. 5 Arquitetura de modelo baseada em framework codificador-decodificador para geração de legendas de imagens

Tabela 2 Desempenho dos modelos baseados em codificador-decodificador no conjunto de dados MSCOCO

Modelo B-1 B-2 B-3 B-4 METEORO CIDRA ROUGEL

62,5 45,0 32.1 23,0 19,5 66,0 –
Alinhamento Profundo

SCA-CNN 71.9 54,8 41.1 31.1 25,0 – –

PG 75,4 59.1 44,5 33.2 25,7 101,3 55,0

IAS – – – 27,7 23,7 85,5 –

VDD 73,7 66,4 57.1 50,5 34,7 125,0 64,9

Os modelos propostos por Karpathy et al. [18] (DeepAlign), Chen et al. [19] (SCA CNN), Vinyals et al.
[28] (NIC), Liu et al. [29] (PG), e Asadi et al. [31] (VDD) são
avaliados em um conjunto de dados de legendagem de imagens popular proposto por Lin et al. [32] chamado
MSCOCO. Os modelos propostos são avaliados usando as pontuações BLEU, METEOR
pontuação [33], pontuação CIDEr [34] e pontuação ROUGEL [35] e os resultados são relatados
na Tabela 2. Todos esses modelos usaram CNNs como codificador.

3.3 Vídeo como Entrada

Outro tipo de problemas que os modelos codificador-decodificador desempenham um papel importante

resolvê-los são aqueles com vídeos como entrada e descrevendo texto como saída,
também chamado de “Geração de descrição de vídeo” ou “Legenda de vídeo”. Desde a criação de um
uma boa representação é fundamental para o desempenho geral dos modelos de legendas de vídeo,
uma ampla variedade de codificadores é proposta para lidar com diferentes dificuldades e comprimentos de
tais sistemas. Esta seção apresenta alguns exemplos de codificadores propostos
para lidar com os desafios de extrair detalhes de movimento do vídeo.
Suponha que um vídeo de entrada V consiste em quadros Li . Podemos apresentar o vídeo como em
eq. (10), em que vI é uma representação do i- ésimo quadro no vídeo de entrada e vLi é
o fim do token de vídeo (<EOV>). De fato, cada vi é o vetor de características extraído por um
CNN no i- ésimo quadro no vídeo de entrada.
Machine Translated by Google

O Encoder-Decoder Framework e suas aplicações 145

Fig. 6 Uma ilustração do primeiro modelo baseado em codificador-decodificador para legendagem de vídeo

V = {v0, v1,..., vLi} (10)

Como no modelo codificador-decodificador de linha de base, o codificador deve retornar um vetor

de contexto de “comprimento fixo” extraído da entrada, uma função de agregação é necessária para
agregar vetores de recursos de diferentes quadros no vídeo e passá-lo como vetor de contexto para
o decodificador .
Diferentes ideias foram empregadas para propor uma boa agregação para legendagem de vídeo.
A primeira abordagem baseada em codificador-decodificador de ponta a ponta na geração de
descrição de vídeo proposta por Venugopalan et al. em 2014 [4] usaram uma camada média de
pooling para criar o vetor de contexto de comprimento fixo a partir do vídeo de entrada. Nesse
modelo, primeiro uma CNN é aplicada a cada quadro do vídeo de entrada. Em seguida, uma camada
de agrupamento médio é aplicada para criar um vetor de recursos médio sobre o conjunto de vetores
de recursos extraídos de cada quadro. O vetor de característica médio é então passado para o
decodificador para gerar a sentença. Uma estrutura RNN empilhada é usada como decodificador. A
Figura 6 demonstra a arquitetura do primeiro modelo baseado em codificador-decodificador para legendagem de vídeo
Diferentes CNNs foram usadas para extrair vetores de recursos dos quadros do vídeo de entrada.
Por exemplo, Majd et al. [36] propuseram uma versão estendida das células LSTM, chamada
“C2LSTM”, na qual os dados de movimento, bem como as características espaciais e as dependências
temporais são percebidas pela incorporação de uma camada de modelagem de correlação na célula.
Majd et ai. [37] também propuseram uma nova arquitetura de rede usando o C2LSTM proposto
anteriormente como o codificador para reconhecimento de ação humana.

3.3.1 3D-CNNs

Extrair boas características do vídeo de entrada é uma tarefa desafiadora que pode afetar muito o
desempenho do modelo proposto. O vetor de contexto extraído do vídeo de entrada deve expressar
bem os movimentos detalhados no vídeo. A fim de criar
Machine Translated by Google

146 A. Asadi e R. Safabakhsh

Fig. 7 A estrutura do 3D-CNN

um codificador capaz de extrair características de movimento fino do vídeo, Yao et al. [38]
propuseram um 3D-CNN como codificador. A estrutura deste 3D-CNN é ilustrada na Fig. 7.

Na verdade, o 3D-CNN proposto modela as dependências espaço-temporais no vídeo de

entrada. O 3D-CNN é usado para construir uma representação de nível superior que preserva
as informações de movimento local de sequências de quadros curtos no vídeo de entrada.
Isso é feito dividindo primeiro o clipe de vídeo de entrada em uma grade espaço-temporal 3D
de 16 * 12 * 2 (largura * altura * intervalos de tempo) paralelepípedos. Cada cubóide é
representado pela concatenação do histograma de gradientes orientados (HOG), histograma
de fluxo orientado (HOF) e histograma de limite de movimento (MBH) com 33 bins. Essa
transformação garante que as estruturas temporais locais e os recursos de movimento sejam
bem extraídos. O descritor 3D gerado então é passado para 3 camadas convolucionais, cada
uma seguida por uma camada max-pooling e uma camada totalmente conectada seguida por
uma camada softmax, conforme demonstrado na Fig. 7. A saída do 3D-CNN é então passada
para o decodificador para gerar uma legenda apropriada.
O 3D-CNN proposto por Yao et al. [38] também é usado ao lado da típica CNN 2D em
outros trabalhos. Pan et ai. [39] propuseram uma nova arquitetura de codificador-decodificador
para geração de descrição de vídeo e usaram o 3D-CNN e o típico 2D-CNN e aplicaram uma
camada média de pooling ao conjunto de recursos extraídos por cada uma das CNNs e
concatenaram a saída para gerar o vetor de contexto do vídeo. A Figura 8 ilustra a parte do
codificador deste modelo.
Machine Translated by Google

O Encoder-Decoder Framework e suas aplicações 147

Fig. 8 Uma ilustração da estrutura do codificador que usa uma combinação de CNNs 2D e 3D
da CNN
Machine Translated by Google

148 A. Asadi e R. Safabakhsh

3.3.2 Fornecer legendas de vídeo

Outra abordagem para legendagem de vídeo inclui os métodos focados em “Dense Video
Captioning”. Apesar dos modelos que geram uma única frase como descrição do vídeo de entrada,
os modelos de legendagem de vídeo densos primeiro detectam e localizam os eventos existentes
no vídeo de entrada e depois geram uma frase de descrição para cada um dos eventos detectados.

Os codificadores para legendas de vídeo densas devem primeiro detectar todos os eventos
existentes no vídeo de entrada. Então, para cada um dos eventos, um quadruplo < tstart,
tend ,score, h > deve ser extraído. tstart e tend são os números de quadro inicial e final do evento
especificado. score é a pontuação de confiança do codificador para cada um dos eventos. Se a
pontuação de um evento for maior que um limite, ele é relatado como um evento e seu quádruplo
é passado ao decodificador para geração de sentença; caso contrário, é ignorado. Finalmente, h
é o vetor de características extraído do intervalo de quadros entre tstart e tend que é usado pelo
decodificador como vetor de contexto do evento para gerar uma sentença para o evento [40].

A tarefa de legendagem de vídeo densa foi proposta por Krishna et al. [41] pela primeira vez
em 2017. O codificador proposto por Krishna et al. [41] para legendagem de vídeo denso é capaz
de identificar eventos do vídeo de entrada dentro de uma única passagem enquanto o decodificador
proposto gera simultaneamente legendas para cada evento detectado e passado pelo codificador.
A Figura 9 ilustra a estrutura do codificador proposta por Krishna et al. [41] para legendas de
vídeo densas. O codificador proposto é capaz de extrair todos os eventos no vídeo de entrada
usando um módulo de proposta de ação profunda (DAP) proposto por [42]. Para fazer isso, um 3D-
CNN é aplicado aos quadros de vídeo de entrada para extrair os recursos de vídeo. Esses
recursos de vídeo são passados para o módulo DAP. Este módulo consiste em diferentes LSTMs
que são aplicados à sequência de recursos de vídeo em diferentes resoluções e são treinados
para detectar pontos de início e término de eventos. A pontuação de confiança de cada evento é

Fig. 9 Uma ilustração do modelo de codificador para legendas de vídeo densas

Machine Translated by Google

O Encoder-Decoder Framework e suas aplicações 149

também calculado pelo DAP. As propostas de eventos propostas são então classificadas em relação
aos seus pontos finais e passadas sequencialmente para o decodificador. O vetor de características
de cada evento também é o estado oculto do RNN correspondente no DAP. O decodificador então
gera uma sentença para cada evento usando seu vetor de características como saída do codificador.
Li et ai. [40] propuseram uma nova abordagem baseada em codificador-decodificador de ponta a
ponta para legendagem de vídeo densa que unificou a localização temporal de propostas de eventos
e geração de sentenças. A Figura 10 ilustra a estrutura do modelo proposto [40]. Aqui, em vez de
usar um módulo DAP extra, uma estrutura convolucional de 12 camadas é projetada para extrair
recursos para propostas de ação sobre a saída do 3D-CNN. As primeiras 3 camadas da estrutura
convolucional (camada 500D e camadas de base na Fig. 10) são projetadas para introduzir não
linearidades e diminuir a dimensão de entrada. As próximas 9 camadas, que são chamadas de
“camadas âncora”, extraem recursos de diferentes resoluções para serem usados na previsão de
eventos. A “Camada de Previsão” consiste em três camadas paralelas totalmente conectadas para
primeiro regredir as coordenadas temporais (tstart e tend) de cada evento, depois calcular a
descritividade do evento (pontuação) e, finalmente, classificar o evento versus o plano de fundo. A
camada de previsão é aplicada à saída de todas as camadas âncoras para permitir que o modelo
detecte eventos de diferentes resoluções. As propostas extraídas são então passadas para o módulo
de classificação de propostas, que classifica as propostas de eventos em relação ao horário de
término. Por fim, os eventos são passados ao decodificador para geração de sentenças
sequencialmente.
Uma grande variedade de modelos é proposta para lidar com as dificuldades da fase de
codificação em legendagem de vídeo densa. Shen et ai. [43] propuseram uma nova CNN chamada
“Lexical FCN”, que é treinada de maneira fracamente supervisionada para detectar eventos com base
nas legendas no conjunto de dados. Duan et ai. também propôs uma nova abordagem para
legendagem de vídeo densa com base na suposição semelhante “cada legenda descreve um
segmento temporal, e cada segmento temporal tem uma legenda” [44]. Xu et ai. propuseram um
modelo baseado em codificador-decodificador de ponta a ponta para legendagem de vídeo densa
que detecta e descreve eventos no vídeo de entrada em conjunto e é aplicável à legendagem de
vídeo densa em fluxos de vídeo. Zhu et ai. também propôs uma abordagem de ponta a ponta com
uma rede de mascaramento para localizar e descrever eventos em conjunto [45]. Wang et ai. propôs
uma nova arquitetura para levar em consideração os quadros passados e futuros ao localizar os
eventos no vídeo de entrada usando [46] modelos bidirecionais.
Os modelos propostos por Venugopalan et al. [4] (LSTM-YT), Venugopalan et al.
[47] (S2VT), Yao et al. [38] (3D-CNN), e Pan et al. [39] (LSTM-E) para legendagem de vídeo são
avaliados no conjunto de dados Youtube2Text proposto por Chen et al. [48], cujos resultados são
relatados na Tabela 3.
Os modelos LSTM-YT e S2VT usam codificadores semelhantes. Em ambos os modelos, uma
CNN é usada para extrair um vetor de características de cada quadro no vídeo. Os vetores de
recursos extraídos são então passados para uma camada de pool de médias para gerar um vetor de
recursos unificado para representar o vídeo de entrada. No modelo 3D-CNN, um 3D-CNN é usado
junto com um 2D-CNN para extrair e representar informações sobre os movimentos no vídeo de
entrada. O vetor de recursos extraído neste modelo contém informações espaço-temporais extraídas
do vídeo. O modelo LSTM-E utilizou células LSTM como codificador. Como resultado, o vetor de
recursos extraído representa a informação temporal do vídeo de entrada.
Machine Translated by Google

150 A. Asadi e R. Safabakhsh

Fig. 10 Uma ilustração da estrutura codificador-decodificador para legendas de vídeo densas

Machine Translated by Google

O Encoder-Decoder Framework e suas aplicações 151

Tabela 3 Desempenho de diferentes modelos baseados em codificador-decodificador para legendas de vídeo

Modelo B-1 B-2 B-3 B-4 TEMPO cidra

LSTM-YT – – – 33.29 29,7 –

S2VT – – – – 29,8 –

3D-CNN – – – 41,92 29,6 51,67

LSTM-E 78,8 66,0 55,4 45,3 31,0 –

O principal problema desafiador nos codificadores do codificador-decodificador baseado

modelos na geração de combinação de descrição de vídeo, é extrair uma
a informação temporal do vídeo de entrada.

4 Variedades de Estrutura de Decodificador

Nos modelos baseados em codificador-decodificador, os decodificadores geram uma saída sequencial para
a entrada dada. A saída gerada pode estar na forma de um texto descritivo
(a saída desejada em tradução automática, legendagem de imagem/vídeo, texto/visual
resposta a perguntas e conversão de fala para texto) ou um sinal de fala (o
saída no desafio de conversão de texto em fala). A saída é uma sequência numérica que
é passado para a última camada para gerar uma saída apropriada para o dado
entrada. Portanto, as principais estruturas dos decodificadores são semelhantes em diferentes tarefas.
Esta seção apresenta diferentes técnicas propostas para fazer melhores decodificadores com
legendas melhor geradas.

4.1 Dependências de Longo Prazo

Um dos problemas básicos com RNNs é o problema das “dependências de longo prazo”.
De fato, quando o comprimento da entrada ou o comprimento da saída desejada é muito grande, o
gradientes nessas redes devem se propagar por muitos estágios. Quando o gradiente
é propagado por um grande número de estágios, ele tende a desaparecer ou explodir.
Além disso, os gradientes em cada etapa de retropropagação são multiplicados por pequenas
coeficientes ou pequenas taxas de aprendizagem. Assim, o gradiente nos estágios iniciais será
próximo de zero e pode não fazer nenhuma mudança significativa nos pesos do estágio inicial
camadas [49].
Nesta seção, discutiremos as abordagens propostas para lidar com o problema de longo prazo.
desafio de dependência nos decodificadores.