From 906668757b775858059962ed88286ca69c39f1b4 Mon Sep 17 00:00:00 2001 From: Leon Silva Date: Mon, 25 Apr 2022 12:29:43 -0300 Subject: [PATCH] [PT] Adding weeks 3 to 6 (#805) * adding weeks 03 to 06 * [PT] Adding weeks 03 to 06 * [PT] fix: Alf reviews for PR #805 > > Co-authored-by: Felipe Schiavon Co-authored-by: Bernardo Lago " Co-authored-by: Alfredo Canziani --- docs/_config.yml | 18 + docs/pt/week03/03-1.md | 487 +++++ docs/pt/week03/03-2.md | 476 +++++ docs/pt/week03/03-3.md | 285 +++ docs/pt/week03/03.md | 40 + docs/pt/week03/lecture03.sbv | 3428 ++++++++++++++++++++++++++++++ docs/pt/week03/practicum03.sbv | 1751 ++++++++++++++++ docs/pt/week04/04-1.md | 596 ++++++ docs/pt/week04/04.md | 18 + docs/pt/week04/practicum04.sbv | 1517 ++++++++++++++ docs/pt/week05/05-1.md | 451 ++++ docs/pt/week05/05-2.md | 512 +++++ docs/pt/week05/05-3.md | 490 +++++ docs/pt/week05/05.md | 40 + docs/pt/week05/lecture05.sbv | 3572 ++++++++++++++++++++++++++++++++ docs/pt/week05/practicum05.sbv | 1241 +++++++++++ docs/pt/week06/06-1.md | 285 +++ docs/pt/week06/06-2.md | 585 ++++++ docs/pt/week06/06-3.md | 734 +++++++ docs/pt/week06/06.md | 36 + docs/pt/week06/lecture06.sbv | 3338 +++++++++++++++++++++++++++++ docs/pt/week06/practicum06.sbv | 1742 ++++++++++++++++ 22 files changed, 21642 insertions(+) create mode 100644 docs/pt/week03/03-1.md create mode 100644 docs/pt/week03/03-2.md create mode 100644 docs/pt/week03/03-3.md create mode 100644 docs/pt/week03/03.md create mode 100644 docs/pt/week03/lecture03.sbv create mode 100644 docs/pt/week03/practicum03.sbv create mode 100644 docs/pt/week04/04-1.md create mode 100644 docs/pt/week04/04.md create mode 100644 docs/pt/week04/practicum04.sbv create mode 100644 docs/pt/week05/05-1.md create mode 100644 docs/pt/week05/05-2.md create mode 100644 docs/pt/week05/05-3.md create mode 100644 docs/pt/week05/05.md create mode 100644 docs/pt/week05/lecture05.sbv create mode 100644 docs/pt/week05/practicum05.sbv create mode 100644 docs/pt/week06/06-1.md create mode 100644 docs/pt/week06/06-2.md create mode 100644 docs/pt/week06/06-3.md create mode 100644 docs/pt/week06/06.md create mode 100644 docs/pt/week06/lecture06.sbv create mode 100644 docs/pt/week06/practicum06.sbv diff --git a/docs/_config.yml b/docs/_config.yml index 066387c99..ab0c24d2b 100644 --- a/docs/_config.yml +++ b/docs/_config.yml @@ -760,6 +760,24 @@ pt: - path: pt/week02/02-1.md - path: pt/week02/02-2.md - path: pt/week02/02-3.md + - path: pt/week03/03.md + sections: + - path: pt/week03/03-1.md + - path: pt/week03/03-2.md + - path: pt/week03/03-3.md + - path: pt/week04/04.md + sections: + - path: pt/week04/04-1.md + - path: pt/week05/05.md + sections: + - path: pt/week05/05-1.md + - path: pt/week05/05-2.md + - path: pt/week05/05-3.md + - path: pt/week06/06.md + sections: + - path: pt/week06/06-1.md + - path: pt/week06/06-2.md + - path: pt/week06/06-3.md - path: pt/week07/07.md sections: - path: pt/week07/07-1.md diff --git a/docs/pt/week03/03-1.md b/docs/pt/week03/03-1.md new file mode 100644 index 000000000..5d3d0db79 --- /dev/null +++ b/docs/pt/week03/03-1.md @@ -0,0 +1,487 @@ +--- +lang: pt +lang-ref: ch.03-1 +lecturer: Yann LeCun +title: Visualização da Transformação de Parâmetros de Redes Neurais e Conceitos Fundamentais de Convoluções +authors: Jiuhong Xiao, Trieu Trinh, Elliot Silva, Calliea Pan +date: 10 Feb 2020 +typora-root-url: 03-1 +translation-date: 14 Nov 2021 +translator: Leon Solon +--- + + + + +## [Visualização de redes neurais](https://www.youtube.com/watch?v=FW5gFiJb-ig&t=5s) + + + +Nesta seção, visualizaremos o funcionamento interno de uma rede neural. + + + +
Network
+Fig. 1 Estrutura da rede
+ + + +A Figura 1 mostra a estrutura da rede neural que gostaríamos de visualizar. Normalmente, quando desenhamos a estrutura de uma rede neural, a entrada aparece na parte inferior ou à esquerda e a saída aparece na parte superior ou direita. Na Figura 1, os neurônios de cor rosa representam as entradas e os neurônios azuis representam as saídas. Nesta rede, temos 4 camadas ocultas (em verde), o que significa que temos 6 camadas no total (4 camadas ocultas + 1 camada de entrada + 1 camada de saída). Nesse caso, temos 2 neurônios por camada oculta e, portanto, a dimensão da matriz de peso ($W$) para cada camada é 2 por 2. Isso ocorre porque queremos transformar nosso plano de entrada em outro plano que possamos visualizar. + + + +
Network
+Fig. 2 Visualização do espaço dobrável
+ + + +A transformação de cada camada é como dobrar nosso plano em algumas regiões específicas, conforme mostrado na Figura 2. Esse dobramento é muito abrupto, isso porque todas as transformações são realizadas na camada 2D. No experimento, descobrimos que, se tivermos apenas 2 neurônios em cada camada oculta, a otimização será mais demorada; a otimização é mais fácil se tivermos mais neurônios nas camadas ocultas. Isso nos deixa com uma questão importante a considerar: por que é mais difícil treinar a rede com menos neurônios nas camadas ocultas? Você mesmo deve considerar esta questão e retornaremos a ela após a visualização de $\texttt{ReLU}$. + + + +| Network | Network | +|(a)|(b)| + + + +
Fig. 3 Visualização do operador ReLU
+ + + +Quando percorremos a rede, uma camada oculta de cada vez, vemos que, em cada camada, realizamos alguma transformação afim, seguida pela aplicação da operação ReLU não linear, que elimina quaisquer valores negativos. Nas Figuras 3 (a) e (b), podemos ver a visualização do operador ReLU. O operador ReLU nos ajuda a fazer transformações não lineares. Após várias etapas de realização de uma transformação afim seguida pelo operador ReLU, somos eventualmente capazes de separar linearmente os dados, como pode ser visto na Figura 4. + + + +
Network
+Fig. 4 Visualização de saídas
+ + + +Isso nos fornece algumas dicas sobre por que as camadas ocultas de 2 neurônios são mais difíceis de treinar. Nossa rede de 6 camadas tem um viés em cada camada oculta. Portanto, se uma dessas polarizações mover pontos para fora do quadrante superior direito, a aplicação do operador ReLU eliminará esses pontos para zero. Depois disso, não importa o quanto as camadas posteriores transformem os dados, os valores permanecerão zero. Podemos tornar uma rede neural mais fácil de treinar tornando a rede "mais gorda" - *ou seja,* adicionando mais neurônios em camadas ocultas - ou podemos adicionar mais camadas ocultas, ou uma combinação dos dois métodos. Ao longo deste curso, exploraremos como determinar a melhor arquitetura de rede para um determinado problema, fique atento. + + + +## [Transformações de parâmetro](https://www.youtube.com/watch?v=FW5gFiJb-ig&t=477s) + + + +A transformação de parâmetro geral significa que nosso vetor de parâmetro $w$ é a saída de uma função. Por meio dessa transformação, podemos mapear o espaço de parâmetro original em outro espaço. Na Figura 5, $ w $ é na verdade a saída de $H$ com o parâmetro $u$. $G (x, w)$ é uma rede e $C(y,\bar y)$ é uma função de custo. A fórmula de retropropagação também é adaptada da seguinte forma, + + + +$$ +u \leftarrow u - \eta\frac{\partial H}{\partial u}^\top\frac{\partial C}{\partial w}^\top +$$ + + + +$$ +w \leftarrow w - \eta\frac{\partial H}{\partial u}\frac{\partial H}{\partial u}^\top\frac{\partial C}{\partial w}^\top +$$ + + + +Essas fórmulas são aplicadas em forma de matriz. Observe que as dimensões dos termos devem ser consistentes. As dimensões de $u$,$w$,$\frac{\partial H}{\partial u}^\top$,$\frac{\partial C}{\partial w}^\top$ são $[N_u \times 1]$,$[N_w \times 1]$,$[N_u \times N_w]$,$[N_w \times 1]$, respectivamente. Portanto, a dimensão de nossa fórmula de retropropagação é consistente. + + + +
Network
+Fig. 5 Forma geral das transformações de parâmetros
+ + + +### Uma transformação de parâmetro simples: compartilhamento de peso + + + +Uma transformação de compartilhamento de peso significa que $H(u)$ apenas replica um componente de $u$ em vários componentes de $w$. $H(u)$ é como uma divisão em **Y** para copiar $u_1$ para $w_1$, $w_2$. Isso pode ser expressado como, + + + +$$ +w_1 = w_2 = u_1, w_3 = w_4 = u_2 +$$ + + + +Forçamos os parâmetros compartilhados a serem iguais, então o gradiente em relação aos parâmetros compartilhados será somado na retroprogação. Por exemplo, o gradiente da função de custo $C(y, \bar y)$ em relação a $u_1$ será a soma do gradiente da função de custo $C(y, \bar y)$ em relação a $w_1$ e o gradiente da função de custo $C(y, \bar y)$ em relação a $w_2$. + + + +### Hiper-rede + + + +Uma hiper-rede é uma rede em que os pesos de uma rede são a saída de outra rede. A Figura 6 mostra o gráfico de computação de uma "hiper-rede". Aqui, a função $H$ é uma rede com vetor de parâmetro $u$ e entrada $x$. Como resultado, os pesos de $G(x,w)$ são configurados dinamicamente pela rede $H(x,u)$. Embora seja uma ideia antiga, continua muito poderosa. + + + +
Network
+Fig. 6 "Hypernetwork"
+ + + +### Detecção de motivos em dados sequenciais + + + +A transformação de compartilhamento de peso pode ser aplicada à detecção de motivos. A detecção de motivos significa encontrar alguns motivos em dados sequenciais, como palavras-chave em voz ou texto. Uma maneira de conseguir isso, conforme mostrado na Figura 7, é usar uma janela deslizante de dados, que move a função de divisão de peso para detectar um motivo específico (*ou seja* um determinado som no sinal de fala) e as saídas (*ou seja,* uma pontuação) vai para uma função máxima. + + + +
Network
+Fig. 7 Detecção de Motivos para Dados Sequenciais
+ + + +Neste exemplo, temos 5 dessas funções. Como resultado dessa solução, somamos cinco gradientes e retropropagamos o erro para atualizar o parâmetro $w$. Ao implementar isso no PyTorch, queremos evitar o acúmulo implícito desses gradientes, então precisamos usar `zero_grad()` para inicializar o gradiente. + + + +### Detecção de motivos em imagens + + + +A outra aplicação útil é a detecção de motivos em imagens. Normalmente, passamos nossos "modelos" sobre as imagens para detectar as formas, independentemente da posição e distorção das formas. Um exemplo simples é distinguir entre "C" e "D", como mostra a Figura 8. A diferença entre "C" e "D" é que "C" tem dois pontos finais e "D" tem dois cantos. Assim, podemos projetar "modelos de terminal" e "modelos de canto". Se a forma for semelhante aos "modelos", ele terá saídas limitadas. Então, podemos distinguir as letras dessas saídas, somando-as. Na Figura 8, a rede detecta dois pontos finais e zero cantos, portanto, ativa "C". + + + +
Network
+Fig. 8 Detecção de motivos para imagens
+ + + +Também é importante que o nosso "modelo de correspondência" seja invariante ao deslocamento - quando mudamos a entrada, a saída (*ou seja,* a letra detectada) não deve mudar. Isso pode ser resolvido com a transformação do compartilhamento de peso. Como mostra a Figura 9, quando mudamos a localização de "D", ainda podemos detectar os motivos dos cantos, embora eles estejam deslocados. Ao somarmos os motivos, ele ativará a detecção "D". + + + +
Network
+Fig. 9 Invariância de deslocamento
+ + + +Este método artesanal de usar detectores locais e soma para reconhecimento de dígitos foi usado por muitos anos. Mas isso nos apresenta o seguinte problema: Como podemos criar esses "modelos" automaticamente? Podemos usar redes neurais para aprender esses "modelos"? A seguir, apresentaremos o conceito de **convoluções**, ou seja, a operação que usamos para combinar imagens com "modelos". + + + +## Convolução discreta + + + +### Convolução + + + +A definição matemática precisa de uma convolução no caso unidimensional entre a entrada $x$ e $w$ é: + + + +$$y_i = \sum_j w_j x_{i-j}$$ + + + +Em palavras, a $i$-ésima saída é calculada como o produto escalar entre o $w$ **invertido** e uma janela do mesmo tamanho em $x$. Para calcular a saída completa, inicie a janela no início, avance esta janela um passo de cada vez e repita até que $x$ se esgote. + + + +### Correlação cruzada + + + +Na prática, a convenção adotada em estruturas de aprendizado profundo, como o PyTorch, é um pouco diferente. Na implementação das convoluções no PyTorch, $w$ **não é invertido**: + + + +$$y_i = \sum_j w_j x_{i+j}$$ + + + +Os matemáticos chamam essa formulação de "correlação cruzada". Em nosso contexto, essa diferença é apenas uma diferença na convenção. Praticamente, correlação cruzada e convolução podem ser intercambiáveis ​​se alguém ler os pesos armazenados na memória para frente ou para trás. + + + +Estar ciente dessa diferença é importante, por exemplo, quando se deseja fazer uso de certas propriedades matemáticas de convolução / correlação de textos matemáticos. + + + +### Convolução dimensional superior + + + +Para entradas bidimensionais, como imagens, usamos a versão bidimensional da convolução: + + + +$$y_{ij} = \sum_{kl} w_{kl} x_{i+k, j+l}$$ + + + +Essa definição pode ser facilmente estendida além de duas dimensões para três ou quatro dimensões. Aqui $w$ é chamado de *kernel de convolução* + + + +### Torções regulares que podem ser feitas com o operador convolucional em DCNNs + + + +1. **Striding**: em vez de mudar a janela em $x$ uma entrada por vez, pode-se fazer isso com um passo maior (por exemplo, duas ou três entradas por vez). +Exemplo: suponha que a entrada $x$ seja unidimensional e tenha tamanho 100 e $w$ tenha tamanho 5. O tamanho de saída com uma passada de 1 ou 2 é mostrado na tabela abaixo: + + + +| Stride | 1 | 2 | +| ------------ | -------------------------- | -------------------------- | +| Tamanho da saída: | $\frac{100 - (5-1)}{1}=96$ | $\frac{100 - (5-1)}{2}=48$ | + + + +2. **Preenchimento (Padding)**: Muito frequentemente, ao projetar arquiteturas de Redes Neurais Profundas, queremos que a saída de convolução seja do mesmo tamanho que a entrada. Isso pode ser obtido preenchendo as extremidades da entrada com um número de entradas (normalmente) de zero, geralmente em ambos os lados. O enchimento é feito principalmente por conveniência. Isso às vezes pode afetar o desempenho e resultar em efeitos de borda estranhos, ou seja, ao usar uma não linearidade ReLU, o preenchimento de zero não é irracional. + + + +## Redes Neurais de Convolução Profunda (DCNNs) + + + +Conforme descrito anteriormente, as redes neurais profundas são normalmente organizadas como alternância repetida entre operadores lineares e camadas não lineares pontuais. Em redes neurais convolucionais, o operador linear será o operador de convolução descrito acima. Também existe um terceiro tipo opcional de camada, denominado camada de pool. + + + +A razão para empilhar várias dessas camadas é que queremos construir uma representação hierárquica dos dados. As CNNs não precisam se limitar a processar imagens; elas também foram aplicadas com sucesso à fala e à linguagem. Tecnicamente, eles podem ser aplicados a qualquer tipo de dado que venha na forma de arrays, embora também utilizemos esses arrays para satisfazer certas propriedades. + + + +Por que desejaríamos capturar a representação hierárquica do mundo? Porque o mundo em que vivemos é composto. Este ponto é mencionado nas seções anteriores. Essa natureza hierárquica pode ser observada a partir do fato de que os pixels locais se reúnem para formar motivos simples, como bordas orientadas. Essas bordas, por sua vez, são montadas para formar características locais, como cantos, junções em T, etc. Essas bordas são montadas para formar motivos que são ainda mais abstratos. Podemos continuar construindo sobre essas representações hierárquicas para, eventualmente, formar os objetos que observamos no mundo real. + + + +
CNN Features
+Figura 10. Visualização de recurso de rede convolucional treinada em ImageNet de [Zeiler & Fergus 2013]
+ + + +Essa natureza composicional e hierárquica que observamos no mundo natural não é, portanto, apenas o resultado de nossa percepção visual, mas também verdadeira no nível físico. No nível mais baixo de descrição, temos partículas elementares, que se agrupam para formar átomos, átomos juntos formam moléculas. Continuamos a desenvolver esse processo para formar materiais, partes de objetos e, eventualmente, objetos completos no mundo físico. + + + +A natureza composicional do mundo pode ser a resposta à pergunta retórica de Einstein sobre como os humanos entendem o mundo em que vivem: + + + +> A coisa mais incompreensível sobre o universo é que ele é compreensível. + + + +O fato de os humanos entenderem o mundo graças a essa natureza composicional ainda parece uma conspiração para Yann. No entanto, argumenta-se que, sem composicionalidade, será necessário ainda mais magia para os humanos compreenderem o mundo em que vivem. Citando o grande matemático Stuart Geman: + + + +> O mundo é composicional ou Deus existe. + + + +## [Inspirações na Biologia](https://www.youtube.com/watch?v=FW5gFiJb-ig&t=2254s) + + + +Então, por que o Deep Learning deveria estar enraizado na ideia de que nosso mundo é compreensível e tem uma natureza composicional? A pesquisa conduzida por Simon Thorpe ajudou a motivar isso ainda mais. Ele mostrou que a maneira como reconhecemos objetos do cotidiano é extremamente rápida. Seus experimentos envolviam gerar um conjunto de imagens a cada 100 ms e, em seguida, pedir aos usuários que identificassem essas imagens, o que eles foram capazes de fazer com sucesso. Isso demonstrou que leva cerca de 100 ms para os humanos detectarem objetos. Além disso, considere o diagrama abaixo, ilustrando partes do cérebro anotadas com o tempo que leva para os neurônios se propagarem de uma área para a próxima: + + + +
Simon_Thorpe
+ + + +
Figura 11. Modelo de Simon Thorpe de fluxo de informações visuais no cérebro
+ + + +Os sinais passam da retina para o LGN (ajuda com aumento de contraste, controle de porta, etc.), em seguida, para o córtex visual primário V1, V2, V4 e, em seguida, para o córtex inferotemporal (PIT), que é a parte do cérebro onde categorias são definidas. As observações da cirurgia de cérebro aberto mostraram que, se você mostrar um filme a um humano, os neurônios no PIT serão disparados apenas quando detectarem certas imagens - como Jennifer Aniston ou a avó de uma pessoa - e nada mais. Os disparos neurais são invariáveis ​​a coisas como posição, tamanho, iluminação, orientação de sua avó, o que ela está vestindo, etc. + + + +Além disso, os tempos de reação rápidos com os quais os humanos foram capazes de categorizar esses itens - apenas o tempo suficiente para alguns picos passarem - demonstra que é possível fazer isso sem tempo adicional gasto em cálculos recorrentes complexos. Em vez disso, este é um único processo de feed-forward. + + + +Esses insights sugeriram que poderíamos desenvolver uma arquitetura de rede neural que é completamente feed-forward, mas ainda capaz de resolver o problema de reconhecimento, de uma forma que é invariável para transformações irrelevantes de entrada. + + + +Um outro insight do cérebro humano vem de Gallant & Van Essen, cujo modelo do cérebro humano ilustra duas vias distintas: + + + +
Gallant_and_Van_Essen
+ + + +
Figura 12. Modelo de Gallen e Van Essen das vias dorsais e ventrais no cérebro
+ + + +O lado direito mostra a via ventral, que indica o que você está olhando, enquanto o lado esquerdo mostra a via dorsal, que identifica localizações, geometria e movimento. Eles parecem bastante separados no córtex visual humano (e primata) (com algumas interações entre eles, é claro). + + + +### Contribuições de Hubel & Weisel (1962) + + + +
Hubel_and_Weisel
+ + + +
Figura 13. Experimentos de Hubel e Wiesel com estímulos visuais em cérebros de gatos
+ + + +Os experimentos de Hubel e Weisel usaram eletrodos para medir disparos neurais em cérebros de gatos em resposta a estímulos visuais. Eles descobriram que os neurônios na região V1 são sensíveis apenas a certas áreas de um campo visual (chamadas de "campos receptivos") e detectam bordas orientadas nessa área. Por exemplo, eles demonstraram que se você mostrasse ao gato uma barra vertical e começasse a girá-la, em um determinado ângulo o neurônio dispararia. Da mesma forma, conforme a barra se afasta desse ângulo, a ativação do neurônio diminui. Hubel & Weisel denominaram esses neurônios seletivos de ativação de "células simples", por sua capacidade de detectar características locais. + + + +Eles também descobriram que se você mover a barra para fora do campo receptivo, aquele neurônio específico não dispara mais, mas outro neurônio o faz. Existem detectores de características locais que correspondem a todas as áreas do campo visual, daí a ideia de que o cérebro humano processa informações visuais como uma coleção de "circunvoluções". + + + +Outro tipo de neurônio, que eles chamaram de "células complexas", agregam a saída de várias células simples dentro de uma determinada área. Podemos pensar nisso como o cálculo de um agregado das ativações usando uma função como máximo, soma, soma dos quadrados ou qualquer outra função que não dependa da ordem. Essas células complexas detectam bordas e orientações em uma região, independentemente de onde esses estímulos estejam especificamente na região. Em outras palavras, eles são invariáveis ​​ao deslocamento em relação a pequenas variações nas posições da entrada. + + + +### Contribuições de Fukushima (1982) + + + +
Fukushima
+ + + +
Figura 14. Modelo CNN de Fukushima
+ + + +Fukushima foi o primeiro a implementar a ideia de múltiplas camadas de células simples e células complexas com modelos de computador, usando um conjunto de dados de dígitos escritos à mão. Alguns desses detectores de recursos foram feitos à mão ou aprendidos, embora o aprendizado usasse algoritmos de agrupamento não supervisionados, treinados separadamente para cada camada, já que a retropropagação ainda não estava em uso. + + + +Yann LeCun veio alguns anos depois (1989, 1998) e implementou a mesma arquitetura, mas desta vez os treinou em um ambiente supervisionado usando retropropagação. Isso é amplamente considerado como a gênese das redes neurais convolucionais modernas. (Observação: Riesenhuber no MIT em 1999 também redescobriu essa arquitetura, embora ele não tenha usado a retropropagação.) diff --git a/docs/pt/week03/03-2.md b/docs/pt/week03/03-2.md new file mode 100644 index 000000000..8b178c8ba --- /dev/null +++ b/docs/pt/week03/03-2.md @@ -0,0 +1,476 @@ +--- +lang: pt +lang-ref: ch.03-2 +lecturer: Yann LeCun +title: Evolução, Arquiteturas, Detalhes de Implementação e Vantagens das Redes Convolucionais. +authors: Chris Ick, Soham Tamba, Ziyu Lei, Hengyu Tang +date: 10 Feb 2020 +translation-date: 14 Nov 2021 +translator: Leon Solon +--- + + + + +## [Proto-CNNs e evolução para CNNs modernas](https://www.youtube.com/watch?v=FW5gFiJb-ig&t=2949s) + + + + +### Redes neurais protoconvolucionais em pequenos conjuntos de dados + + + +Inspirado pelo trabalho de Fukushima na modelagem do córtex visual, o uso da hierarquia celular simples / complexa combinada com treinamento supervisionado e retropropagação levou ao desenvolvimento da primeira CNN na Universidade de Toronto em '88-'89 pelo Prof. Yann LeCun. Os experimentos usaram um pequeno conjunto de dados de 320 dígitos 'escritos no mouse'. Os desempenhos das seguintes arquiteturas foram comparados: + + + +1. Camada FC única (totalmente conectada) +2. Duas camadas FC +3. Camadas conectadas localmente sem pesos compartilhados +4. Rede restrita com pesos compartilhados e conexões locais +5. Rede restrita com pesos compartilhados e conexões locais 2 (mais mapas de recursos) + + + +As redes mais bem-sucedidas (rede restrita com pesos compartilhados) tiveram a generalização mais forte e formam a base para as CNNs modernas. Enquanto isso, a camada FC simples tende a se ajustar demais. + + + + +### Primeiras ConvNets "reais" na Bell Labs + + + +Depois de se mudar para o Bell Labs, a pesquisa de LeCunn mudou para o uso de códigos postais manuscritos dos Correios dos EUA para treinar uma CNN maior: + + + +* 256 (16$\times$16) camada de entrada +* 12 5$\times$5 kernels com *stride* 2 (com passos de 2 pixels): a próxima camada tem resolução mais baixa +* **Sem** pooling em separado + + + + +### Arquitetura de rede convolucional com pooling + + + +No ano seguinte, algumas mudanças foram feitas: o pooling separado foi introduzido. O agrupamento separado é feito calculando a média dos valores de entrada, adicionando uma polarização e passando para uma função não linear (função tangente hiperbólica). O pool de 2 $ \ vezes $ 2 foi realizado com um passo de 2, reduzindo, portanto, as resoluções pela metade. + + + +
+
+ Fig. 1 Arquitetura ConvNet +
+ + + +Um exemplo de uma única camada convolucional seria o seguinte: +1. Pegue uma entrada com tamanho *32$\times$32* +2. A camada de convolução passa um kernel 5$\times$5 com *stride* 1 sobre a imagem, resultando no tamanho do mapa de características *28$\times$28* +3. Passe o mapa de características para uma função não linear: tamanho *28$\times$28* +4. Passe para a camada de agrupamento que tem em média uma janela de 2$\times$2 com *stride* 2 (passo 2): tamanho *14$\times$14* +5. Repita 1-4 para 4 kernels + + + +As combinações simples de convolução/pool de primeira camada geralmente detectam recursos simples, como detecções de bordas orientadas. Após a primeira camada de convolução/pool, o objetivo é detectar combinações de recursos de camadas anteriores. Para fazer isso, as etapas 2 a 4 são repetidas com vários kernels sobre os mapas de recursos da camada anterior e são somados em um novo mapa de recursos: + + + +1. Um novo kernel 5$\times$5 é deslizado sobre todos os mapas de características das camadas anteriores, com os resultados somados. (Observação: no experimento do Prof. LeCun em 1989, a conexão não está completa para fins de computação. As configurações modernas geralmente impõem conexões completas): tamanho *10$\times$10* +2. Passe a saída da convolução para uma função não linear: tamanho *10$\times$10* +3. Repita 1/2 para 16 grãos. +4. Passe o resultado para a camada de agrupamento que tem em média mais de 2$\times$2 janela com passo 2: tamanho *5$\times$5* cada mapa de característica + + + +Para gerar uma saída, a última camada de convolução é conduzida, que parece conexões completas, mas na verdade é convolucional. + + + +1. A camada de convolução final desliza um kernel 5$\times$5 sobre todos os mapas de características, com resultados resumidos: tamanho *1$\times$1* +2. Passagem pela função não linear: tamanho *1$\times$1* +3. Gere o resultado único para uma categoria. +4. Repita todas as etapas anteriores para cada uma das 10 categorias (em paralelo) + + + +Veja [esta animação] (http://cs231n.github.io/convolutional-networks/) no site de Andrej Karpathy sobre como as convoluções mudam a forma dos mapas de características da próxima camada. O artigo completo pode ser encontrado [aqui](https://papers.nips.cc/paper/293-handwritten-digit-recognition-with-a-back-propagation-network.pdf). + + + + +### Equivariância de deslocamento (Shift equivariance) + + + +
+
+ Fig. 2 Equivariância de deslocamento (Shift Equivariance) +
+ + + +Conforme demonstrado pela animação nos slides (aqui está outro exemplo), a tradução da imagem de entrada resulta na mesma tradução dos mapas de características. No entanto, as mudanças nos mapas de recursos são dimensionadas por operações de convolução/agrupamento. *Por exemplo, o agrupamento de 2$\times$2 com *stride* 2 (passo de 2) reduzirá o deslocamento de 1 pixel na camada de entrada para o deslocamento de 0,5 pixel nos seguintes mapas de características. A resolução espacial é então trocada por um número maior de tipos de recursos, *ou seja,* tornando a representação mais abstrata e menos sensível a deslocamentos e distorções. + + + + +### Análise geral da arquitetura + + + +A arquitetura genérica da CNN pode ser dividida em vários arquétipos de camadas básicas: + + + +* **Normalização** + * Ajustando o clareamento (opcional) + * Métodos subtrativos *por exemplo* remoção média, filtragem passa-alta + * Divisivo: normalização de contraste local, normalização de variância + + + +* **Bancos de filtros** + * Aumente a dimensionalidade + * Projeção em base supercompleta + * Detecções de borda + + + +* **Não linearidades** + * Esparsificação + * Unidade Linear Retificada(ReLU): $\text{ReLU}(x) = \max(x, 0)$ + + + +* **Pooling** + * Agragação a partir de um mapa de características + * Max Pooling: $\text{MAX}= \text{Max}_i(X_i)$ + + + + * Pooling de Norma LP: $$\text{L}p= \left(\sum_{i=1}^n \|X_i\|^p \right)^{\frac{1}{p}}$$ + + + + * Pooling de Probabilidade Logarítimica: $\text{Prob}= \frac{1}{b} \left(\sum_{i=1}^n e^{b X_i} \right)$ + + + + +## [LeNet5 e reconhecimento de dígitos](https://www.youtube.com/watch?v=FW5gFiJb-ig&t=3830s) + + + + +### Implementação da LeNet5 no PyTorch + + + +LeNet5 consiste nas seguintes camadas (1 sendo a camada superior): + + + +1. Log-softmax +2. Camada de dimensões totalmente conectada 500$\times$10 +3. ReLu +4. Camada de dimensões totalmente conectada (4$\times$4$\times$50)$\times$500 +5. Combinação máxima de dimensões 2$\times$2, *stride* de 2 (passo de 2). +6. ReLu +7. Convolução com 20 canais de saída, kernel 5$\times$5, *stride* de 1. +8. Combinação máxima de dimensões 2$\times$2, *stride* de 2. +9. ReLu +10. Convolução com 20 canais de saída, 5$\times$5 kernel, *stride* de 1. + + + +A entrada é uma imagem em escala de cinza de 32$\times$32 (1 canal de entrada). + + + +LeNet5 pode ser implementado em PyTorch com o seguinte código: + + + +```python +class LeNet5(nn.Module): + def __init__(self): + super().__init__() + self.conv1 = nn.Conv2d(1, 20, 5, 1) + self.conv2 = nn.Conv2d(20, 20, 5, 1) + self.fc1 = nn.Linear(4*4*50, 500) + self.fc2 = nn.Linear(500, 10) + + def forward(self, x): + x = F.relu(self.conv1(x)) + x = F.max_pool2d(x, 2, 2) + x = F.relu(self.conv2(x)) + x = F.max_pool2d(x, 2, 2) + x = x.view(-1, 4*4*50) + x = F.relu(self.fc1) + x = self.fc2(x) + + return F.logsoftmax(x, dim=1) +``` + + + +Embora `fc1` e` fc2` sejam camadas totalmente conectadas, elas podem ser consideradas camadas convolucionais cujos núcleos cobrem toda a entrada. Camadas totalmente conectadas são usadas para fins de eficiência. + + + +O mesmo código pode ser expresso usando `nn.Sequential`, mas está desatualizado. + + + + +## Vantagens das CNNs + + + +Em uma rede totalmente convolucional, não há necessidade de especificar o tamanho da entrada. No entanto, alterar o tamanho da entrada altera o tamanho da saída. + + + +Considere um sistema de reconhecimento de escrita cursiva. Não precisamos quebrar a imagem de entrada em segmentos. Podemos aplicar o CNN em toda a imagem: os kernels cobrirão todos os locais da imagem inteira e registrarão a mesma saída, independentemente de onde o padrão esteja localizado. Aplicar a CNN sobre uma imagem inteira é muito mais barato do que aplicá-la em vários locais separadamente. Nenhuma segmentação anterior é necessária, o que é um alívio porque a tarefa de segmentar uma imagem é semelhante a reconhecer uma imagem. + + + + +### Exemplo: MNIST + + + +LeNet5 é treinado em imagens MNIST de tamanho 32 $ \ vezes $ 32 para classificar dígitos individuais no centro da imagem. O aumento de dados foi aplicado deslocando o dígito, alterando o tamanho do dígito, inserindo dígitos ao lado. Também foi treinado com uma 11ª categoria que não representou nenhuma das anteriores. As imagens rotuladas por esta categoria foram geradas produzindo imagens em branco ou colocando dígitos na lateral, mas não no centro. + + + +
+
+ Fig. 3 ConvNet (Rede Convolucional) com janela deslizante +
+ + + +A imagem acima demonstra que uma rede LeNet5 treinada em 32$\times$32 pode ser aplicada em uma imagem de entrada de 32$\times$64 para reconhecer o dígito em vários locais. + + + + +## [Problema de vinculação de características](https://www.youtube.com/watch?v=FW5gFiJb-ig&t=4827s) + + + + +### Qual é o problema de vinculação de recursos (Feature Binding)? + + + +Cientistas da neurologia visual e especialistas em visão computacional têm o problema de definir o objeto como um objeto. Um objeto é uma coleção de recursos, mas como vincular todos os recursos para formar esse objeto? + + + + +### Como solucionar? + + + +Podemos resolver esse problema de vinculação de recursos usando um CNN muito simples: apenas duas camadas de convoluções com agrupamentos mais outras duas camadas totalmente conectadas sem nenhum mecanismo específico para isso, visto que temos não linearidades e dados suficientes para treinar nosso CNN. + + + +
+
+ Fig. 4 ConvNet solucionando a vinculação de características (Feature Binding) +
+ + + +A animação acima mostra a capacidade da CNN de reconhecer diferentes dígitos movendo um único traço, demonstrando sua capacidade de resolver problemas de vinculação de recursos, *ou seja,* reconhecendo recursos de forma hierárquica e composicional. + + + + +### Example: comprimento de entrada dinâmica + + + +Podemos construir um CNN com 2 camadas de convolução com passo 1 e 2 camadas de pool com passo 2, de modo que o passo geral seja 4. Assim, se quisermos obter uma nova saída, precisamos mudar nossa janela de entrada em 4. Para ser mais explícito, podemos ver a figura abaixo (unidades verdes). Primeiro, temos uma entrada de tamanho 10 e realizamos a convolução de tamanho 3 para obter 8 unidades. Depois disso, realizamos o pooling de tamanho 2 para obter 4 unidades. Da mesma forma, repetimos a convolução e o agrupamento novamente e, eventualmente, obtemos 1 saída. + + + +
+
+ Fig. 5 Arquitetura ConvNet na vinculação de tamanho de entrada variante +
+ + + +Vamos supor que adicionamos 4 unidades na camada de entrada (unidades rosa acima), de modo que possamos obter mais 4 unidades após a primeira camada de convolução, mais 2 unidades após a primeira camada de agrupamento, mais 2 unidades após a segunda camada de convolução e 1 mais saída. Portanto, o tamanho da janela para gerar uma nova saída é 4 (*stride* de 2 $\times$2). Além disso, esta é uma demonstração de que se aumentarmos o tamanho da entrada, aumentaremos o tamanho de cada camada, comprovando a capacidade das CNNs em lidar com entradas de comprimento dinâmico. + + + + +## No que as CNNs são boas + + + +CNNs são bons para sinais naturais que vêm na forma de matrizes multidimensionais e têm três propriedades principais: +1. **Localidade**: O primeiro é que existe uma forte correlação local entre os valores. Se pegarmos dois pixels próximos de uma imagem natural, é muito provável que esses pixels tenham a mesma cor. À medida que dois pixels se tornam mais distantes, a semelhança entre eles diminui. As correlações locais podem nos ajudar a detectar características locais, que é o que as CNNs estão fazendo. Se alimentarmos a CNN com pixels permutados, ela não terá um bom desempenho no reconhecimento das imagens de entrada, enquanto o FC não será afetado. A correlação local justifica conexões locais. +2. **Estacionaridade**: O segundo caráter é que as características são essenciais e podem aparecer em qualquer lugar da imagem, justificando os pesos compartilhados e pooling. Além disso, os sinais estatísticos são distribuídos uniformemente, o que significa que precisamos repetir a detecção do recurso para cada local na imagem de entrada. +3. **Composicionalidade**: O terceiro caráter é que as imagens naturais são composicionais, ou seja, os recursos compõem uma imagem de forma hierárquica. Isso justifica o uso de múltiplas camadas de neurônios, o que também corresponde intimamente às pesquisas de Hubel e Weisel sobre células simples e complexas. + + + +Além disso, as pessoas fazem bom uso das CNNs em vídeos, imagens, textos e reconhecimento de fala. \ No newline at end of file diff --git a/docs/pt/week03/03-3.md b/docs/pt/week03/03-3.md new file mode 100644 index 000000000..2adb70108 --- /dev/null +++ b/docs/pt/week03/03-3.md @@ -0,0 +1,285 @@ +--- +lang: pt +lang-ref: ch.03-3 +title: Propriedades dos sinais naturais +lecturer: Alfredo Canziani +authors: Ashwin Bhola, Nyutian Long, Linfeng Zhang, and Poornima Haridas +date: 11 Feb 2020 +translation-date: 14 Nov 2021 +translator: Leon Solon +--- + + + + +## [Propriedades dos sinais naturais](https://www.youtube.com/watch?v=kwPWpVverkw&t=26s) + + + +Todos os sinais podem ser considerados vetores. Como exemplo, um sinal de áudio é um sinal 1D $\boldsymbol{x} = [x_1, x_2, \cdots, x_T]$ onde cada valor $x_t$ representa a amplitude da forma de onda no tempo $ t $. Para entender o que alguém está falando, sua cóclea primeiro converte as vibrações da pressão do ar em sinais e, em seguida, seu cérebro usa um modelo de linguagem para converter esse sinal em uma linguagem *ou seja,* ele precisa escolher a expressão mais provável dado o sinal. Para música, o sinal é estereofônico, com 2 ou mais canais para dar a ilusão de que o som vem de várias direções. Embora tenha 2 canais, ainda é um sinal 1D porque o tempo é a única variável ao longo da qual o sinal está mudando. + + + +Uma imagem é um sinal 2D porque a informação é representada espacialmente. Observe que cada ponto pode ser um vetor em si. Isso significa que se temos $d$ canais em uma imagem, cada ponto espacial na imagem é um vetor de dimensão $d$. Uma imagem colorida tem planos RGB, o que significa $d = 3$. Para qualquer ponto $x_{i,j}$, isso corresponde à intensidade das cores vermelha, verde e azul, respectivamente. + + + +Podemos até representar a linguagem com a lógica acima. Cada palavra corresponde a um vetor one-hot com um na posição em que ocorre em nosso vocabulário e zeros em todas as outras. Isso significa que cada palavra é um vetor do tamanho do vocabulário. + + + +Os sinais de dados naturais seguem estas propriedades: +1. Estacionariedade: Certos motivos se repetem ao longo de um sinal. Em sinais de áudio, observamos o mesmo tipo de padrões repetidamente em todo o domínio temporal. Em imagens, isso significa que podemos esperar que padrões visuais semelhantes se repitam em toda a dimensionalidade. +2. Localidade: os pontos próximos são mais correlacionados do que os pontos distantes. Para o sinal 1D, isso significa que se observarmos um pico em algum ponto $t_i$, esperamos que os pontos em uma pequena janela em torno de $t_i$ tenham valores semelhantes a $t_i$, mas para um ponto $t_j$ longe de $t_i$, $x_{t_i}$ tem muito menos influência em $x_{t_j}$. Mais formalmente, a convolução entre um sinal e sua contraparte invertida tem um pico quando o sinal está perfeitamente sobreposto à sua versão invertida. Uma convolução entre dois sinais 1D (correlação cruzada) nada mais é do que seu produto escalar, que é uma medida de quão semelhantes ou próximos os dois vetores são. Assim, a informação está contida em porções e partes específicas do sinal. Para imagens, isso significa que a correlação entre dois pontos em uma imagem diminui à medida que afastamos os pontos. Se $x_{0,0}$ pixel for azul, a probabilidade de que o próximo pixel ($x_{1,0}, x_{0,1}$) também seja azul é muito alta, mas conforme você se move para a extremidade oposta da imagem ($x_{- 1, -1}$), o valor deste pixel é independente do valor do pixel em $x_{0,0}$. +3. Composicionalidade: Tudo na natureza é composto de partes que são compostas de sub-partes e assim por diante. Por exemplo, os caracteres formam cadeias de caracteres que formam palavras, que também formam frases. As frases podem ser combinadas para formar documentos. A composicionalidade permite que o mundo seja explicável. + + + +Se nossos dados exibem estacionariedade, localidade e composicionalidade, podemos explorá-los com redes que usam dispersão, compartilhamento de peso e empilhamento de camadas. + + + +## [Explorando propriedades de sinais naturais para construir invariância e equivariância](https://www.youtube.com/watch?v=kwPWpVverkw&t=1074s) + + + +### Localidade $\Rightarrow$ esparcidade + + + +A Fig.1 mostra uma rede de 5 camadas totalmente conectada. Cada seta representa um peso a ser multiplicado pelas entradas. Como podemos ver, essa rede é muito cara em termos computacionais. + + + +

+ Figura 1: Rede totalmente conectada
+ + + +Se nossos dados exibem localidade, cada neurônio precisa ser conectado a apenas alguns neurônios locais da camada anterior. Assim, algumas conexões podem ser interrompidas, conforme mostrado na Fig.2. A Fig.2 (a) representa uma rede FC. Aproveitando a propriedade de localidade de nossos dados, eliminamos as conexões entre neurônios distantes na Fig.2 (b). Embora os neurônios da camada oculta (verde) na Fig.2 (b) não abranjam toda a entrada, a arquitetura geral será capaz de dar conta de todos os neurônios de entrada. O campo receptivo (RF) é o número de neurônios das camadas anteriores, que cada neurônio de uma determinada camada pode ver ou levou em consideração. Portanto, o RF da camada de saída com a camada oculta é 3, o RF da camada oculta com a camada de entrada é 3, mas o RF da camada de saída com a camada de entrada é 5. + + + +| | | +|Figura 2 (a):Antes de aplicar a esparcidade | Figura 2(b): Após a aplicação da esparcidade | + + + +### Estacionariedade $\Rightarrow$ Compartilhamento de parâmetros + + + +Se nossos dados exibirem estacionariedade, poderíamos usar um pequeno conjunto de parâmetros várias vezes na arquitetura da rede. Por exemplo, em nossa rede esparsa, Fig.3 (a), podemos usar um conjunto de 3 parâmetros compartilhados (amarelo, laranja e vermelho). O número de parâmetros cairá de 9 para 3! A nova arquitetura pode até funcionar melhor porque temos mais dados para treinar esses pesos específicos. +Os pesos após a aplicação de dispersão e compartilhamento de parâmetros são chamados de kernel de convolução. + + + +| | | Figura 3 (a): Antes de Aplicar o Compartilhamento de Parâmetro | Figura 3 (b): Após aplicar o compartilhamento de parâmetro | + + + +A seguir estão algumas vantagens de usar esparsidade e compartilhamento de parâmetros: - +* Compartilhamento de parâmetros + * convergência mais rápida + * melhor generalização + * não restrito ao tamanho de entrada + * independência do kernel $\Rightarrow$ alta paralelização +* Esparsidade de conexão + * quantidade reduzida de computação + + + +A Fig.4 mostra um exemplo de kernels em dados 1D, onde o tamanho do kernel é: 2(número de kernels) * 7(espessura da camada anterior) * 3(número de conexões / pesos únicos). + + + +A escolha do tamanho do kernel é empírica. A convolução 3 * 3 parece ser o tamanho mínimo para dados espaciais. A convolução de tamanho 1 pode ser usada para obter uma camada final que pode ser aplicada a uma imagem de entrada maior. O tamanho do kernel de número par pode diminuir a qualidade dos dados, portanto, sempre temos o tamanho do kernel de números ímpares, geralmente 3 ou 5. + + + +| | | +| Figura 4 (a): Kernels em dados 1D | Figura 4 (b): Dados com Preenchimento com Zeros | + + + +### Preenchimento (Padding) + + + +O preenchimento (padding) geralmente prejudica os resultados finais, mas é conveniente programaticamente. Normalmente usamos preenchimento com zeros (zero-padding): `tamanho = (tamanho do kernel - 1)/2`. + + + +### CNN espacial padrão + + + +Uma CNN espacial padrão tem as seguintes propriedades: + + + +* Múltiplas camadas + * Convolução + * Não linearidade (ReLU e Leaky) + * Pooling + * Normalização em lote (batch normalization) +* Conexão de bypass residual + + + +A normalização em lote e as conexões de bypass residuais são muito úteis para fazer com que a rede treine bem. +Partes de um sinal podem se perder se muitas camadas forem empilhadas, portanto, conexões adicionais via bypass residual garantem um caminho de baixo para cima e também um caminho para gradientes vindo de cima para baixo. + + + +Na Fig.5, enquanto a imagem de entrada contém principalmente informações espaciais em duas dimensões (além das informações características, que são a cor de cada pixel), a camada de saída é espessa. No meio do caminho, há uma troca entre as informações espaciais e as informações características e a representação torna-se mais densa. Portanto, à medida que subimos na hierarquia, obtemos uma representação mais densa à medida que perdemos as informações espaciais. + + + +

+ Figura 5: Representações de informações subindo na hierarquia
+ + + +### [Pooling](https://www.youtube.com/watch?v=kwPWpVverkw&t=2376s) + + + +

+ Figura 6: Ilustração de pooling
+ + + +Um operador específico, $L_p$-norm, é aplicado a diferentes regiões (consulte a Fig.6). Esse operador fornece apenas um valor por região (1 valor para 4 pixels em nosso exemplo). Em seguida, iteramos sobre todos os dados, região por região, realizando etapas com base no passo. Se começarmos com $m * n$ dados com $c$ canais, terminaremos com $\frac{m}{2} * \frac{n}{2}$ dados ainda com $c$ canais (consulte Fig.7). +O agrupamento não é parametrizado; no entanto, podemos escolher diferentes tipos de sondagem, como pooling máximo, pooling médio e assim por diante. O objetivo principal do agrupamento reduz a quantidade de dados para que possamos computar em um período de tempo razoável. + + + +

+ Figura 7: Agrupando resultados
+ + + +## CNN - Jupyter Notebook + + + +O Jupyter Notebook pode ser encontrado [aqui](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/06-convnet.ipynb). Para executar o notebook, certifique-se de ter o ambiente `pDL` instalado conforme especificado em [`README.md`](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/README.md) . + + + +Neste notebook, treinamos um perceptron multicamadas (rede totalmente conectada - FC) e uma rede neural convolucional (CNN) para a tarefa de classificação no conjunto de dados MNIST. Observe que ambas as redes têm um número igual de parâmetros. (Fig.8) + + + +

+ Figura 8: instâncias do conjunto de dados MNIST original
+ + + +Antes do treinamento, normalizamos nossos dados para que a inicialização da rede corresponda à nossa distribuição de dados (muito importante!). Além disso, certifique-se de que as cinco operações/etapas a seguir estejam presentes em seu treinamento: + + + +1. Alimentando dados para o modelo +2. Calculando a perda +3. Limpar o cache de gradientes acumulados com `zero_grad()` +4. Calculando os gradientes +5. Executar uma etapa no método do otimizador + + + +Primeiro, treinamos ambas as redes nos dados MNIST normalizados. A precisão da rede totalmente conectada acabou sendo $87\%$, enquanto a precisão da CNN acabou sendo $95\%$. Dado o mesmo número de parâmetros, a CNN conseguiu treinar muitos mais filtros. Na rede FC, os filtros que tentam obter algumas dependências entre coisas que estão mais distantes com coisas que estão por perto são treinados. Eles estão completamente perdidos. Em vez disso, na rede convolucional, todos esses parâmetros se concentram na relação entre os pixels vizinhos. + + + +Em seguida, realizamos uma permutação aleatória de todos os pixels em todas as imagens de nosso conjunto de dados MNIST. Isso transforma nossa Fig.8 em Fig.9. Em seguida, treinamos ambas as redes neste conjunto de dados modificado. + + + +

+ Figura 9: instâncias do conjunto de dados MNIST permutado
+ + + +O desempenho da rede totalmente conectada quase permaneceu inalterado ($85\%$), mas a precisão da CNN caiu para $83\%$. Isso ocorre porque, após uma permutação aleatória, as imagens não possuem mais as três propriedades de localidade, estacionariedade e composicionalidade, que são exploradas por uma CNN. + diff --git a/docs/pt/week03/03.md b/docs/pt/week03/03.md new file mode 100644 index 000000000..8e652a19d --- /dev/null +++ b/docs/pt/week03/03.md @@ -0,0 +1,40 @@ +--- +lang: pt +lang-ref: ch.03 +title: Semana 3 +translator: Leon Solon +translation-date: 14 Nov 2021 +--- + + + +## Aula parte A + + + +Iniciamos com a visualização de uma rede neural de 6 camadas. A seguir, começamos com o tópico de Convoluções e Redes Neurais Convolucionais (CNN). Revisamos vários tipos de transformações de parâmetros no contexto de CNNs e apresentamos a ideia de um kernel, que é usado para aprender características de maneira hierárquica. Assim, podemos classificar nossos dados de entrada, que é a ideia básica que motiva o uso de CNNs. + + + +## Aula parte B + + + +Damos uma introdução de como as CNNs evoluíram ao longo do tempo. Discutimos em detalhes diferentes arquiteturas de CNN, incluindo uma implementação moderna de LeNet5 para exemplificar a tarefa de reconhecimento de dígitos no conjunto de dados MNIST. Com base em seus princípios de design, expandimos as vantagens das CNNs, o que nos permite explorar as características de composicionalidade, estacionariedade e localidade de imagens naturais. + + + +## Prática + + + +As propriedades dos sinais naturais que são mais relevantes para as CNNs são discutidas em mais detalhes, a saber: Localidade, Estacionaridade e Composicionalidade. Exploramos precisamente como um kernel explora essas características por meio de dispersão, compartilhamento de peso e empilhamento de camadas, além de motivar os conceitos de preenchimento (padding) e pooling. Finalmente, uma comparação de desempenho entre FCN (Redes Convolucionais Completas) e CNN foi feita para diferentes modalidades de dados. \ No newline at end of file diff --git a/docs/pt/week03/lecture03.sbv b/docs/pt/week03/lecture03.sbv new file mode 100644 index 000000000..0a0a91f44 --- /dev/null +++ b/docs/pt/week03/lecture03.sbv @@ -0,0 +1,3428 @@ +0:00:04.819,0:00:08.319 +Neste caso, temos uma rede que tem uma entrada do lado esquerdo + +0:00:08.959,0:00:14.259 +Normalmente você tem a entrada no lado inferior ou no lado esquerdo. Eles são rosa em meus slides + +0:00:14.260,0:00:17.409 +Então, se você tomar notas, faça-as cor-de-rosa. Não, é brincadeira! + +0:00:18.400,0:00:23.020 +E então temos... Quantas ativações? Quantas camadas ocultas você conta lá? + +0:00:23.539,0:00:27.789 +Quatro camadas ocultas. Então, no geral, quantas camadas a rede tem aqui? + +0:00:28.820,0:00:32.980 +Seis, certo? Porque temos quatro camadas ocultas, mais uma de entrada, mais uma de saída + +0:00:33.649,0:00:37.568 +Então, neste caso, eu tenho dois neurônios por camada, certo? + +0:00:37.569,0:00:41.739 +Então o que isso significa? Quais são as dimensões das matrizes que estamos usando aqui? + +0:00:43.339,0:00:46.119 +Dois por dois. Então, o que essa matriz dois por dois faz? + +0:00:48.739,0:00:51.998 +Vamos! Você tem... Você sabe a resposta para esta pergunta + +0:00:53.359,0:00:57.579 +Rotação, sim. Depois dimensionar, depois cortar e... + +0:00:59.059,0:01:05.469 +reflexão. Fantástico, certo? Então, restringimos nossa rede para realizar todas as operações no plano + +0:01:05.540,0:01:12.380 +Vimos pela primeira vez se eu permitir que a camada oculta tenha uma centena de neurônios de comprimento, podemos... + +0:01:12.380,0:01:13.680 +Uau tudo bem! + +0:01:13.680,0:01:15.680 +Podemos facilmente... + +0:01:18.079,0:01:20.079 +Ai fantástico. O que é isso? + +0:01:21.170,0:01:23.170 +Estamos assistindo filmes agora. Eu vejo... + +0:01:24.409,0:01:29.889 +Ver? Fantástico. O que é isso? Mandaloriano é tão legal, não? OK... + +0:01:32.479,0:01:39.428 +Ok, como é bom esta lição. É mesmo gravado? Ok, não temos ideia + +0:01:40.789,0:01:43.719 +Certo, me dê um segundo. Ok, então vamos aqui... + +0:01:47.810,0:01:49.810 +Feito + +0:01:50.390,0:01:52.070 +Ouvir + +0:01:52.070,0:01:53.600 +Tudo bem + +0:01:53.600,0:01:59.679 +Então a gente começou dessa rede aqui, né? Que tinha essa camada intermediária e nós os forçamos a serem + +0:02:00.289,0:02:05.229 +2 dimensões, certo? De tal forma que todas as transformações são forçadas para estar em um plano + +0:02:05.270,0:02:08.319 +Então é isso que a rede faz com o nosso plano + +0:02:08.319,0:02:14.269 +Ele dobra em regiões específicas, certo? E essas dobras são muito abruptas + +0:02:14.370,0:02:18.499 +Isso porque todas as transformações são realizadas na camada 2d, certo? + +0:02:18.500,0:02:22.550 +Então esse treinamento me exigiu muito esforço porque o + +0:02:23.310,0:02:25.310 +otimização é realmente muito difícil + +0:02:25.740,0:02:30.769 +Sempre que eu tinha uma camada oculta de cem neurônios, isso era muito fácil de treinar + +0:02:30.770,0:02:35.299 +Este realmente exigiu muito esforço e você tem que me dizer por quê, ok? + +0:02:35.400,0:02:39.469 +Se você não sabe a resposta agora, é melhor saber a resposta para o semestre + +0:02:40.470,0:02:43.370 +Então você pode tomar nota de quais são as perguntas para o meio-termo... + +0:02:43.980,0:02:49.600 +Certo, então esta é a saída final da rede, que também é aquela camada 2d + +0:02:50.010,0:02:55.489 +para a incorporação, então não tenho não linearidade na minha última camada. E estes são os finais + +0:02:56.370,0:03:01.850 +regiões de classificação. Então vamos ver o que cada camada faz. Esta é a primeira camada, transformação afim + +0:03:01.850,0:03:06.710 +então parece que é uma rotação 3d, mas não está certo? É apenas uma rotação 2D + +0:03:07.740,0:03:15.600 +reflexão, escala e cisalhamento. E então qual é essa parte? Ah, o que aconteceu agora? Você vê? + +0:03:17.820,0:03:21.439 +Temos como a parte ReLU, que está matando todos os negativos + +0:03:22.800,0:03:27.079 +lados da rede, certo? Desculpe, todos os lados negativos disso + +0:03:28.080,0:03:33.499 +espaço, certo? É a segunda transformação afim e aqui você aplica novamente + +0:03:34.770,0:03:37.460 +o ReLU, você pode ver todos os pontos negativos + +0:03:38.220,0:03:41.149 +subespaços foram apagados e eles foram definidos como zero + +0:03:41.730,0:03:44.509 +Então continuamos com uma terceira transformação afim + +0:03:45.120,0:03:46.790 +Nós ampliamos... está aumentando muito... + +0:03:46.790,0:03:54.469 +E então você vai ter a camada ReLU que vai matar um desses... todos os três quadrantes, certo? + +0:03:54.470,0:03:59.240 +Apenas um quadrante sobrevive a cada vez. E então vamos com a quarta transformação afim + +0:03:59.790,0:04:06.200 +onde está a alongar-se muito porque dado que confinamos toda a transformação a viver neste espaço + +0:04:06.210,0:04:12.439 +ele realmente precisa esticar e usar toda a energia que puder, certo? Novamente, este é o + +0:04:13.170,0:04:18.589 +penúltimo. Então temos a última transformação afim, que é a final. E então chegamos finalmente + +0:04:19.320,0:04:20.910 +linearmente separável + +0:04:20.910,0:04:26.359 +regiões aqui. Por fim, veremos como cada transformação afim pode ser + +0:04:27.240,0:04:31.759 +dividido em cada componente. Então, temos a rotação, agora temos o esmagamento, como o zoom + +0:04:32.340,0:04:38.539 +Então temos rotação, reflexão porque o determinante é menos um, e então temos o viés final + +0:04:38.539,0:04:42.769 +Você tem a parte positiva da ReLU (Unidade Linear Retificada), novamente rotação + +0:04:43.650,0:04:47.209 +lançando porque tínhamos um determinante negativo, menos um + +0:04:47.849,0:04:49.849 +Zoom, rotação + +0:04:49.889,0:04:54.258 +Mais uma reflexão e depois o viés final. Esta foi a segunda transformação afim + +0:04:54.259,0:04:58.609 +Então temos aqui a parte positiva novamente. Nós temos a terceira camada então rotação, reflexão + +0:05:00.000,0:05:05.629 +zoom e então temos... esta é a decomposição SVD, certo? Você deve estar ciente disso, certo? + +0:05:05.629,0:05:09.799 +Você deveria saber. E então final é a tradução e a terceira + +0:05:10.229,0:05:15.589 +ReLU, então tivemos a quarta camada, então rotação, reflexão porque o determinante era negativo + +0:05:16.169,0:05:18.169 +zoom, novamente a outra rotação + +0:05:18.599,0:05:21.769 +Mais uma vez... reflexão e preconceito + +0:05:22.379,0:05:24.559 +Finalmente um ReLU e então temos o último... + +0:05:25.259,0:05:27.259 +a quinta camada. Então rotação + +0:05:28.139,0:05:32.059 +zoom, não tivemos reflexão porque o determinante foi +1 + +0:05:32.490,0:05:37.069 +Novamente, reflexão neste caso porque o determinante foi negativo e depois finalmente o viés final, certo? + +0:05:37.139,0:05:41.478 +E foi assim que essa rede, que foi + +0:05:42.599,0:05:44.599 +apenas feito de + +0:05:44.759,0:05:46.759 +uma sequência de camadas de + +0:05:47.159,0:05:52.218 +neurônios que são apenas dois neurônios por camada, está realizando a tarefa de classificação + +0:05:54.990,0:05:58.159 +E todas essas transformações foram restringidas a ser + +0:05:58.680,0:06:03.199 +morando no avião. Ok, então isso foi muito difícil de treinar + +0:06:03.419,0:06:05.959 +Você consegue descobrir por que foi tão difícil treinar? + +0:06:06.539,0:06:08.539 +O que acontece se o meu... + +0:06:09.270,0:06:16.219 +se meu viés de uma das quatro camadas afasta meus pontos do quadrante superior direito? + +0:06:21.060,0:06:25.519 +Exatamente, então se você tem um dos quatro preconceitos colocando meu + +0:06:26.189,0:06:28.549 +ponto inicial longe do quadrante superior direito + +0:06:29.189,0:06:34.039 +então os ReLUs estarão matando tudo completamente, e tudo será reduzido a zero + +0:06:34.560,0:06:38.399 +OK? E aí você não pode fazer mais nada, então + +0:06:38.980,0:06:44.129 +essa rede aqui foi muito difícil de treinar. Se você apenas torná-lo um pouco mais gordo do que... + +0:06:44.320,0:06:48.659 +em vez de restringi-lo a ser dois neurônios para cada uma das camadas ocultas + +0:06:48.660,0:06:52.230 +então é muito mais fácil treinar. Ou você pode fazer uma combinação dos dois, certo? + +0:06:52.230,0:06:54.300 +Então, em vez de ter apenas uma rede gorda + +0:06:54.300,0:07:01.589 +você pode ter uma rede menos gorda, mas aí você tem algumas camadas escondidas, ok? + +0:07:02.770,0:07:06.659 +Então a gordura é quantos neurônios você tem por camada oculta, certo? + +0:07:07.810,0:07:11.429 +OK. Então a questão é como determinamos a estrutura ou o + +0:07:12.730,0:07:15.150 +configuração da nossa rede, certo? Como projetamos a rede? + +0:07:15.580,0:07:20.550 +E a resposta vai ser, isso é o que Yann vai ensinar ao longo do semestre, certo? + +0:07:20.550,0:07:27.300 +Então mantenha sua atenção alta porque é isso que vamos ensinar aqui + +0:07:28.090,0:07:30.840 +Essa é uma boa pergunta certo? Não há + +0:07:32.410,0:07:34.679 +regra matemática, há um monte de experimentos + +0:07:35.710,0:07:39.569 +evidências empíricas e muitas pessoas estão tentando configurações diferentes + +0:07:39.570,0:07:42.000 +Encontramos algo que realmente funciona muito bem agora. + +0:07:42.100,0:07:46.200 +Vamos cobrir essas arquiteturas nas lições a seguir. Outras perguntas? + +0:07:48.790,0:07:50.790 +Não seja tímido + +0:07:51.880,0:07:56.130 +Não? Ok, então acho que podemos mudar para a segunda parte da aula + +0:07:57.880,0:08:00.630 +Ok, então vamos falar sobre redes convolucionais hoje + +0:08:02.710,0:08:05.879 +Vamos mergulhar de cabeça. Então vou começar com + +0:08:06.820,0:08:09.500 +algo que é relevante para redes convolucionais, mas não apenas [para eles] + +0:08:10.000,0:08:12.500 +que é a ideia de transformar os parâmetros de uma rede neural + +0:08:12.570,0:08:17.010 +Então aqui temos um diagrama que vimos antes, exceto por uma pequena reviravolta + +0:08:17.920,0:08:22.300 +O diagrama que estamos vendo aqui é que temos uma rede neural G de X e W + +0:08:22.360,0:08:27.960 +W sendo os parâmetros, X sendo a entrada que faz uma previsão sobre uma saída, e isso entra em uma função de custo + +0:08:27.960,0:08:29.500 +Já vimos isso antes + +0:08:29.500,0:08:34.500 +Mas a diferença aqui é que o vetor peso em vez de ser um + +0:08:35.830,0:08:39.660 +parâmetro que está sendo otimizado, é na verdade a saída de alguma outra função + +0:08:40.599,0:08:43.589 +possivelmente parametrizado. Neste caso esta função é + +0:08:44.320,0:08:50.369 +não é uma função parametrizada, ou é uma função parametrizada mas a única entrada é outro parâmetro U, ok? + +0:08:50.750,0:08:56.929 +Então, o que fizemos aqui é fazer com que os pesos dessa rede neural sejam a função de algo mais elementar... + +0:08:57.480,0:08:59.480 +alguns parâmetros mais elementares U + +0:09:00.420,0:09:02.420 +através de uma função e + +0:09:02.940,0:09:07.880 +você percebe muito rapidamente que o backprop simplesmente funciona lá, certo? Se você voltar a propagar gradientes + +0:09:09.210,0:09:15.049 +através da função G para obter o gradiente de qualquer função objetivo que estamos minimizando em relação ao + +0:09:15.600,0:09:21.290 +parâmetros de peso, você pode continuar propagando através da função H aqui para obter os gradientes em relação a U + +0:09:22.620,0:09:27.229 +Então, no final, você está meio que propagando coisas assim + +0:09:30.600,0:09:42.220 +Então, quando você está atualizando U, você está multiplicando o Jacobiano da função objetivo em relação aos parâmetros, e então pelo... + +0:09:42.750,0:09:46.760 +Jacobiano da função H em relação aos seus próprios parâmetros, ok? + +0:09:46.760,0:09:50.960 +Então você obtém o produto de dois jacobianos aqui, que é exatamente o que você obtém da propagação de volta + +0:09:50.960,0:09:54.919 +Você não precisa fazer nada no PyTorch para isso. Isso acontecerá automaticamente conforme você define a rede + +0:09:59.130,0:10:03.080 +E esse é o tipo de atualização que ocorre + +0:10:03.840,0:10:10.820 +Agora, é claro, W sendo uma função de U através da função H, a mudança em W + +0:10:12.390,0:10:16.460 +será a mudança em U multiplicada pela Jacobiana de H transposta + +0:10:18.090,0:10:24.739 +E esse é o tipo de coisa que você obtém aqui, a mudança efetiva no W que você obtém sem atualizar o W + +0:10:24.740,0:10:30.260 +--você realmente está atualizando U-- é a atualização em U multiplicada pelo jacobiano de H + +0:10:30.690,0:10:37.280 +E nós tivemos uma transposição aqui. Temos o oposto aí. Esta é uma matriz quadrada + +0:10:37.860,0:10:41.720 +que é Nw por Nw, que é o número de... a dimensão de W ao quadrado, ok? + +0:10:42.360,0:10:44.690 +Então essa matriz aqui + +0:10:45.780,0:10:47.780 +tem tantas linhas quanto + +0:10:48.780,0:10:52.369 +W tem componentes e então o número de colunas é o número de + +0:10:52.560,0:10:57.470 +componentes de U. E então esse cara, é claro, é o contrário, então é um Nu por Nw + +0:10:57.540,0:11:02.669 +Então quando você faz o produto, faça o produto dessas duas matrizes você obtém uma matriz Nw por Nw + +0:11:03.670,0:11:05.670 +E então você multiplica isso por isso + +0:11:06.190,0:11:10.380 +Nw vetor e você obtém um vetor Nw que é o que você precisa para atualizar + +0:11:11.440,0:11:13.089 +os pesos + +0:11:13.089,0:11:16.828 +Ok, então essa é uma forma geral de transformar o espaço de parâmetros e há + +0:11:18.430,0:11:22.979 +muitas maneiras de usar isso e uma maneira particular de usá-lo é quando + +0:11:23.769,0:11:25.389 +H é o que se chama de... + +0:11:26.709,0:11:30.089 +sobre o que falamos na semana passada, que é um "conector Y" + +0:11:30.089,0:11:35.578 +Então imagine que a única coisa que H faz é pegar um componente de U e copiá-lo várias vezes + +0:11:36.029,0:11:40.000 +Para que você tenha o mesmo valor, o mesmo peso replicado na função G + +0:11:40.000,0:11:43.379 +a função G usamos o mesmo valor várias vezes + +0:11:45.639,0:11:47.639 +Então isso ficaria assim + +0:11:48.339,0:11:50.339 +Então vamos imaginar que U é bidimensional + +0:11:51.279,0:11:54.448 +u1, u2 e então W é quadridimensional, mas + +0:11:55.000,0:11:59.969 +w1 e w2 são iguais a u1 e w3, w4 são iguais a u2 + +0:12:01.060,0:12:04.400 +Então, basicamente, você só tem dois parâmetros livres + +0:12:04.700,0:00:00.000 +e quando você está alterando um componente de U alterando dois componentes de W ao mesmo tempo + +0:12:08.560,0:12:14.579 +de uma forma muito simples. E isso se chama compartilhamento de peso, ok? Quando dois pesos são forçados a serem iguais + +0:12:14.579,0:12:19.200 +Eles são na verdade iguais a um parâmetro mais elementar que controla tanto + +0:12:19.300,0:12:21.419 +Isso é compartilhamento de peso e essa é a base da + +0:12:21.940,0:12:23.940 +um monte de + +0:12:24.670,0:12:26.880 +idéias... você sabe, redes convolucionais entre outras + +0:12:27.730,0:12:31.890 +mas você pode pensar nisso como uma forma muito simples de H de U + +0:12:33.399,0:12:38.489 +Então você não precisa fazer nada para isso no sentido de que quando você tem compartilhamento de peso + +0:12:39.100,0:12:45.810 +Se você fizer isso explicitamente com um módulo que faz uma conexão Y no caminho de volta, quando os gradientes são propagados de volta + +0:12:45.810,0:12:47.800 +os gradientes são somados + +0:12:47.800,0:12:53.099 +então o gradiente de alguma função de custo em relação a u1, por exemplo, será a soma do gradiente de modo que + +0:12:53.199,0:12:55.559 +função de custo em relação a w1 e w2 + +0:12:56.860,0:13:02.219 +E da mesma forma para o gradiente em relação a u2 seria a soma dos gradientes em relação a w3 e w4, ok? + +0:13:02.709,0:13:06.328 +Esse é apenas o efeito da retropropagação através dos dois conectores Y + +0:13:13.310,0:13:19.119 +Ok, aqui está uma visão um pouco mais geral dessa transformação de parâmetros que algumas pessoas chamam de hiperredes + +0:13:19.970,0:13:23.350 +Assim, uma hiper-rede é uma rede onde + +0:13:23.839,0:13:28.299 +os pesos de uma rede são calculados como a saída de outra rede + +0:13:28.459,0:13:33.969 +Ok, então você tem uma rede H que olha a entrada, ela tem seus próprios parâmetros U + +0:13:35.569,0:13:37.929 +E calcula os pesos de uma segunda rede + +0:13:38.959,0:13:44.199 +OK? então a vantagem de fazer isso... existem vários nomes para isso + +0:13:44.199,0:13:46.508 +A ideia é muito antiga, remonta aos anos 80 + +0:13:46.880,0:13:52.539 +pessoas usando o que é chamado de interações multiplicativas, ou rede de três vias, ou unidades sigma-pi e eles são basicamente + +0:13:53.600,0:13:59.050 +esta ideia -- e esta é talvez uma formulação geral um pouco mais geral dela + +0:14:00.949,0:14:02.949 +que você tem uma espécie de dinamismo + +0:14:04.069,0:14:06.519 +Sua função que é definida dinamicamente + +0:14:07.310,0:14:09.669 +Em G de X e W + +0:14:10.459,0:14:14.318 +Porque W é realmente uma função complexa da entrada e algum outro parâmetro + +0:14:16.189,0:14:17.959 +Isto é particularmente + +0:14:17.959,0:14:22.419 +arquitetura interessante quando o que você está fazendo com o X está transformando-o de algumas maneiras + +0:14:23.000,0:14:29.889 +Certo? Então você pode pensar em W como sendo os parâmetros dessa transformação, então Y seria uma versão transformada de X + +0:14:32.569,0:14:37.809 +E o X, quero dizer, a função H basicamente calcula essa transformação + +0:14:38.899,0:14:41.739 +OK? Mas voltaremos a isso em algumas semanas + +0:14:42.829,0:14:46.209 +Só queria mencionar isso porque é basicamente uma pequena modificação do + +0:14:46.579,0:14:52.869 +deste certo? Você só tem mais um fio que vai de X a H, e é assim que você obtém essas hiper-redes + +0:14:56.569,0:15:03.129 +Ok, então estamos mostrando a ideia de que você pode ter um parâmetro controlando + +0:15:06.500,0:15:12.549 +vários parâmetros efetivos em outra rede. E uma razão que é útil é + +0:15:13.759,0:15:16.779 +se você quiser detectar um motivo em uma entrada + +0:15:17.300,0:15:20.139 +E você quer detectar esse motivo independentemente de onde ele apareça, ok? + +0:15:20.689,0:15:27.099 +Então digamos que você tenha uma entrada, digamos que é uma sequência, mas pode ser uma imagem, neste caso é uma sequência + +0:15:27.100,0:15:28.000 +Sequência de vetores, digamos + +0:15:28.300,0:15:33.279 +E você tem uma rede que pega uma coleção de três desses vetores, três vetores sucessivos + +0:15:34.010,0:15:36.339 +É esta rede G de X e W e + +0:15:37.010,0:15:42.249 +ele é treinado para detectar um motivo específico desses três vetores. Talvez isso seja... eu não sei + +0:15:42.889,0:15:44.750 +o consumo de energia + +0:15:44.750,0:15:51.880 +Consumo de energia elétrica e, às vezes, você pode querer detectar um sinal ou uma tendência ou algo assim + +0:15:52.519,0:15:54.519 +Ou talvez seja, você sabe... + +0:15:56.120,0:15:58.120 +instrumentos financeiros de algum tipo + +0:15:59.149,0:16:05.289 +Algum tipo de série temporal. Talvez seja um sinal de fala e você queira detectar um som específico que consiste em três + +0:16:06.050,0:16:10.899 +vetores que definem o tipo de conteúdo de áudio desse sinal de fala + +0:16:12.440,0:16:15.709 +E então você gostaria de ser capaz de detectar + +0:16:15.709,0:16:20.469 +se for um sinal de fala e houver um som específico que você precisa detectar para fazer o reconhecimento de fala + +0:16:20.470,0:16:22.630 +Você pode querer detectar o som + +0:16:23.180,0:16:28.690 +A vogal P, certo? O som P onde quer que ocorra em uma sequência + +0:16:28.690,0:16:31.299 +Você quer algum detector que dispare quando o som P for... + +0:16:33.589,0:16:41.439 +... é pronunciado. E então o que gostaríamos de ter é um detector que você possa deslizar e independentemente de onde esse motivo ocorra + +0:16:42.470,0:16:47.500 +detectá-lo. Então o que você precisa ter é alguma rede, alguma função parametrizada que... + +0:16:48.920,0:16:55.029 +Você tem várias cópias dessa função que você pode aplicar a várias regiões na entrada e todas compartilham o mesmo peso + +0:16:55.029,0:16:58.600 +mas você gostaria de treinar todo esse sistema de ponta a ponta + +0:16:58.700,0:17:01.459 +Então, por exemplo, digamos... + +0:17:01.459,0:17:03.459 +Vamos falar um pouco mais sofisticado + +0:17:05.569,0:17:07.688 +coisa aqui onde você tem... + +0:17:11.059,0:17:13.059 +Vamos ver... + +0:17:14.839,0:17:17.349 +Uma palavra-chave que está sendo pronunciada de forma + +0:17:18.169,0:17:22.959 +o sistema ouve o som e deseja detectar quando uma determinada palavra-chave, uma ativação + +0:17:24.079,0:17:28.329 +palavra foi pronunciada, certo? Então essa é a Alexa, certo? + +0:17:28.459,0:17:32.709 +E você diz "Alexa!" e Alexa acorda faz um bong, certo? + +0:17:35.260,0:17:40.619 +Então, o que você gostaria de ter é uma rede que faça uma janela sobre o som e mantenha + +0:17:41.890,0:17:44.189 +em segundo plano, detectando + +0:17:44.860,0:17:47.219 +Mas você gostaria de ser capaz de detectar + +0:17:47.220,0:17:52.020 +onde quer que o som ocorra dentro do quadro que está sendo observado, ou foi ouvido, devo dizer + +0:17:52.300,0:17:56.639 +Então você pode ter uma rede como esta onde você tem detectores replicados + +0:17:56.640,0:17:59.520 +Todos eles compartilham o mesmo peso e, em seguida, a saída que é + +0:17:59.520,0:18:03.329 +a pontuação para saber se algo foi detectado ou não, vai para uma função max + +0:18:04.090,0:18:07.500 +OK? E essa é a saída. E a maneira como você treina um sistema como este + +0:18:08.290,0:18:10.290 +você terá um monte de amostras + +0:18:10.780,0:18:14.140 +Exemplos de áudio em que a palavra-chave + +0:18:14.140,0:18:18.000 +foi pronunciada e um monte de amostras de áudio onde a palavra-chave não foi pronunciada + +0:18:18.100,0:18:20.249 +E então você treina um classificador de 2 classes + +0:18:20.470,0:18:24.689 +Ligue quando "Alexa" estiver em algum lugar neste quadro, desligue quando não estiver + +0:18:25.059,0:18:30.899 +Mas ninguém lhe diz onde a palavra "Alexa" ocorre dentro da janela em que você treina o sistema, ok? + +0:18:30.900,0:18:35.729 +Porque é muito caro para os rotuladores olharem para o sinal de áudio e dizerem exatamente + +0:18:35.730,0:18:37.570 +É aqui que a palavra "Alexa" está sendo pronunciada + +0:18:37.570,0:18:42.720 +A única coisa que eles sabem é que dentro deste segmento de alguns segundos, a palavra foi pronunciada em algum lugar + +0:18:43.450,0:18:48.390 +Ok, então você gostaria de aplicar uma rede como esta que tem esses detectores replicados? + +0:18:48.390,0:18:53.429 +Você não sabe exatamente onde está, mas você percorre esse máximo e deseja treinar o sistema para... + +0:18:53.950,0:18:59.370 +Você deseja propagar o gradiente de volta para que ele aprenda a detectar "Alexa" ou qualquer outra coisa ... + +0:19:00.040,0:19:01.900 +palavra de despertar ocorre + +0:19:01.900,0:19:09.540 +E então o que acontece é que você tem várias cópias -- cinco cópias neste exemplo + +0:19:09.580,0:19:11.580 +desta rede e todos compartilham o mesmo peso + +0:19:11.710,0:19:16.650 +Você pode ver que há apenas um vetor de peso enviando seu valor para cinco + +0:19:17.410,0:19:22.559 +instâncias da mesma rede e então voltamos a propagar através do + +0:19:23.260,0:19:27.689 +cinco cópias da rede, você obtém cinco gradientes, então esses gradientes são somados... + +0:19:29.679,0:19:34.949 +para o parâmetro. Agora, há essa maneira um pouco estranha de implementar no PyTorch e em outros + +0:19:35.740,0:19:41.760 +Frameworks de Deep Learning, que é que esse acúmulo de gradiente em um único parâmetro é feito implicitamente + +0:19:42.550,0:19:46.659 +E é uma razão pela qual antes de fazer um backprop no PyTorch, você precisa zerar o gradiente + +0:19:47.840,0:19:49.840 +Porque há uma espécie de implícito + +0:19:50.510,0:19:52.510 +acúmulo de gradientes quando você faz retropropagação + +0:19:58.640,0:20:02.000 +Ok, então aqui está outra situação em que isso seria útil + +0:20:02.100,0:20:07.940 +E esta é a verdadeira motivação por trás das redes condicionais em primeiro lugar + +0:20:07.940,0:20:09.940 +Qual é o problema de + +0:20:10.850,0:20:15.000 +treinar um sistema para reconhecer a forma independentemente da posição + +0:20:16.010,0:20:17.960 +de onde a forma ocorre + +0:20:17.960,0:20:22.059 +e se há distorções dessa forma na entrada + +0:20:22.850,0:20:28.929 +Portanto, este é um tipo muito simples de rede convolucional que foi construída à mão. não foi treinado + +0:20:28.929,0:20:30.929 +Ele foi projetado à mão + +0:20:31.760,0:20:36.200 +E é projetado explicitamente para distinguir C's de D's + +0:20:36.400,0:20:38.830 +Ok, então você pode desenhar um C na entrada + +0:20:39.770,0:20:41.770 +imagem com resolução muito baixa + +0:20:43.880,0:20:48.459 +E o que distingue os Cs dos Ds é que os Cs têm pontos finais, certo? + +0:20:48.460,0:20:54.610 +O curso meio que acaba, e você pode imaginar projetar um detector para isso. Considerando que estes têm cantos + +0:20:55.220,0:20:59.679 +Então, se você tem um detector de endpoint ou algo que detecta o final de um segmento e + +0:21:00.290,0:21:02.290 +um detector de canto + +0:21:02.330,0:21:06.699 +Onde quer que você detecte cantos, é um D e onde quer que você tenha + +0:21:07.700,0:21:09.700 +segmentos que terminam, é um C + +0:21:11.870,0:21:16.989 +Então aqui está um exemplo de um C. Você pega o primeiro detector, então o pequeno + +0:21:17.750,0:21:19.869 +motivo preto e branco aqui no topo + +0:21:20.870,0:21:24.640 +é um detector de endpoint, ok? Detecta o fim de um + +0:21:25.610,0:21:28.059 +de um segmento e a forma como este + +0:21:28.760,0:21:33.969 +é representado aqui é que os pixels pretos aqui... + +0:21:35.840,0:21:37.929 +Então pense nisso como algum tipo de modelo + +0:21:38.990,0:21:43.089 +Ok, você vai pegar este modelo e passar sobre a imagem de entrada + +0:21:44.510,0:21:51.160 +e você vai comparar esse modelo com a pequena imagem que está colocada embaixo, ok? + +0:21:51.980,0:21:56.490 +E se esses dois corresponderem, a maneira como você determinará se eles correspondem é fazendo um produto escalar + +0:21:56.490,0:22:03.930 +Então você vai pensar nesses pixels preto e branco como valor de +1 ou -1, digamos +1 para preto e -1 para branco + +0:22:05.020,0:22:09.420 +E você vai pensar nesses pixels também como sendo +1 para pretos e -1 para branco e + +0:22:10.210,0:22:16.800 +quando você calcula o produto escalar de uma pequena janela com esse modelo + +0:22:17.400,0:22:22.770 +Se eles forem semelhantes, você obterá um grande valor positivo. Se eles são diferentes, você vai ter um... + +0:22:24.010,0:22:27.629 +valor zero ou negativo. Ou um valor menor, ok? + +0:22:29.020,0:22:35.489 +Então você pega esse pequeno detector aqui e calcula o produto escalar com a primeira janela, segunda janela, terceira janela, etc. + +0:22:35.650,0:22:42.660 +Você muda um pixel toda vez para cada local e lembra o resultado. E o que você ganha é isso, certo? + +0:22:42.660,0:22:43.660 +Então isso é... + +0:22:43.660,0:22:51.640 +Aqui a escala de cinza é uma indicação da correspondência + +0:22:51.640,0:22:57.959 +que na verdade é o produto escalar entre o vetor formado por esses valores + +0:22:58.100,0:23:05.070 +E o patch do local correspondente na entrada. Esta imagem aqui é aproximadamente do mesmo tamanho que aquela imagem + +0:23:06.250,0:23:08.250 +menos efeitos de borda + +0:23:08.290,0:23:13.469 +E você vê que há um... sempre que a saída estiver escura, há uma correspondência + +0:23:14.380,0:23:16.380 +Então você vê um jogo aqui + +0:23:16.810,0:23:20.249 +porque este detector de endpoint aqui corresponde ao + +0:23:20.980,0:23:24.810 +o ponto final. Você vê uma espécie de correspondência aqui na parte inferior + +0:23:25.630,0:23:27.930 +E o outro tipo de valores não são tão + +0:23:28.750,0:23:32.459 +escuro, ok? Não tão forte se você quiser + +0:23:33.250,0:23:38.820 +Agora, se você limitar esses valores, você define a saída para +1 se estiver acima do limite + +0:23:39.520,0:23:41.520 +Zero se estiver abaixo do limite + +0:23:42.070,0:23:46.499 +Você obtém esses mapas aqui, você precisa definir o limite adequadamente, mas o que você obtém é que + +0:23:46.500,0:23:50.880 +esse carinha aqui detectou uma correspondência nas duas pontas do C, ok? + +0:23:52.150,0:23:54.749 +Então agora se você pegar este mapa e resumir + +0:23:56.050,0:23:58.050 +Basta adicionar todos os valores + +0:23:58.600,0:24:00.430 +Você obtém um número positivo + +0:24:00.430,0:24:03.989 +Passe isso pelo limiar, e esse é o seu detector C. Não é um detector C muito bom + +0:24:03.990,0:24:07.859 +Não é um detector muito bom de nada, mas para esses exemplos particulares de C's + +0:24:08.429,0:24:10.210 +e talvez aqueles D's + +0:24:10.210,0:24:16.980 +Vai funcionar, vai ser o suficiente. Agora para o D é semelhante, esses outros detectores aqui destinam-se a detectar os cantos do D + +0:24:17.679,0:24:24.538 +Então, esse cara aqui, esse detector, conforme você passa sobre a entrada, detectará o + +0:24:25.659,0:24:29.189 +canto superior esquerdo e esse cara detectará o canto inferior direito + +0:24:29.649,0:24:33.689 +Depois de atingir o limite, você obterá esses dois mapas onde os cantos são detectados + +0:24:34.509,0:24:37.019 +e então você pode resumir isso e o + +0:24:37.360,0:24:44.729 +O detector D será ligado. Agora, o que você vê aqui é um exemplo de por que isso é bom porque essa detecção agora é invariante ao deslocamento + +0:24:44.730,0:24:49.169 +Então, se eu pegar a mesma entrada D aqui, e eu a deslocar por alguns pixels + +0:24:50.340,0:24:56.279 +E eu corro este detector novamente, ele detectará os motivos onde quer que eles apareçam. A saída será deslocada + +0:24:56.379,0:25:01.559 +Ok, então isso é chamado de equivariância ao deslocamento. Então a saída dessa rede + +0:25:02.590,0:25:10.499 +é equivalente a deslocamento, o que significa que, se eu deslocar a entrada, a saída será deslocada, mas de outra forma inalterada. OK? Isso é equivariância + +0:25:11.289,0:25:12.909 +A invariância seria + +0:25:12.909,0:25:17.398 +se eu mudar, a saída ficará completamente inalterada, mas aqui está modificada + +0:25:17.399,0:25:19.739 +Apenas modificou da mesma maneira que a entrada + +0:25:23.950,0:25:31.080 +E se eu apenas resumir as atividades nos mapas de recursos aqui, não importa onde elas ocorram + +0:25:31.809,0:25:34.199 +Meu detector D ainda será ativado + +0:25:34.929,0:25:38.998 +se eu apenas calcular a soma. Então isso é uma espécie de artesanato + +0:25:39.700,0:25:47.100 +reconhecedor de padrões que usa detectores de recursos locais e, em seguida, resume sua atividade e o que você obtém é uma detecção invariável + +0:25:47.710,0:25:52.529 +Ok, esta é uma maneira bastante clássica de construir certos tipos de sistemas de reconhecimento de padrões + +0:25:53.049,0:25:55.049 +Voltando muitos anos + +0:25:57.730,0:26:03.929 +Mas o truque aqui, o importante é claro, o interessante seria aprender esses templates + +0:26:04.809,0:26:10.258 +Podemos ver isso apenas como uma rede neural e propagarmos de volta para ela e aprendermos esses modelos? + +0:26:11.980,0:26:18.779 +Como pesos de uma rede neural? Afinal, estamos usando-os para fazer aquele produto que é uma soma ponderada, então basicamente + +0:26:21.710,0:26:29.059 +Esta camada aqui para ir da entrada para os chamados mapas de recursos que são somas ponderadas + +0:26:29.520,0:26:33.080 +é uma operação linear, ok? E sabemos como voltar a propagar através disso + +0:26:35.850,0:26:41.750 +Teríamos que usar um tipo de limiar suave, um ReLU ou algo assim aqui porque senão não podemos fazer backprop + +0:26:43.470,0:26:48.409 +Ok, então esta operação aqui de pegar o produto escalar de um monte de coeficientes + +0:26:49.380,0:26:53.450 +com uma janela de entrada e, em seguida, passando-a, isso é uma convolução + +0:26:57.810,0:27:03.409 +Ok, então essa é a definição de uma convolução. Na verdade, é o que está lá em cima, então este é o caso unidimensional + +0:27:05.400,0:27:07.170 +onde imagine que você tem + +0:27:10.530,0:27:16.639 +Uma entrada Xj, então X indexado pelo j no índice + +0:27:20.070,0:27:22.070 +Você pega uma janela + +0:27:23.310,0:27:26.029 +de X em um determinado local i + +0:27:27.330,0:27:30.080 +Ok, e então você soma + +0:27:31.890,0:27:40.340 +Você faz uma soma ponderada da janela dos valores X e os multiplica pelos pesos wⱼ's + +0:27:41.070,0:27:50.359 +Ok, e a soma presumivelmente passa por uma espécie de pequena janela, então j aqui iria de 1 a 5 + +0:27:51.270,0:27:54.259 +Algo assim, que é o caso do pequeno exemplo que mostrei anteriormente + +0:27:58.020,0:28:00.950 +e isso lhe dá um Yi + +0:28:01.770,0:28:05.510 +Ok, então pegue a primeira janela de 5 valores de X + +0:28:06.630,0:28:13.280 +Calcule a soma ponderada com os pesos, que lhe dá Y1. Em seguida, desloque essa janela por 1, calcule a soma ponderada dos + +0:28:13.620,0:28:18.320 +produto escalar dessa janela pelos Y's, que lhe dá Y2, shift novamente, etc. + +0:28:23.040,0:28:26.839 +Agora, na prática, quando as pessoas implementam coisas como PyTorch + +0:28:26.840,0:28:31.069 +há uma confusão entre duas coisas que os matemáticos pensam que são muito diferentes + +0:28:31.070,0:28:37.009 +mas na verdade são praticamente iguais. É convolução e correlação cruzada. Então, em convolução, a convenção é que o... + +0:28:37.979,0:28:44.359 +o índice retrocede na janela quando avança nos pesos + +0:28:44.359,0:28:49.519 +Na correlação cruzada, ambos avançam. No final, é apenas uma convenção, depende de como você se deita... + +0:28:51.659,0:28:59.598 +organizar os dados e seus pesos. Você pode interpretar isso como uma convolução se ler os pesos de trás para frente, então realmente não faz diferença + +0:29:01.259,0:29:06.949 +Mas para certas propriedades matemáticas de uma convolução, se você quer que tudo seja consistente, você precisa ter o... + +0:29:07.440,0:29:10.849 +O j no W com sinal oposto ao j no X + +0:29:11.879,0:29:13.879 +Então a versão bidimensional disso... + +0:29:15.419,0:29:17.419 +Se você tem uma imagem X + +0:29:17.789,0:29:21.258 +que tem dois índices --neste caso i e j + +0:29:23.339,0:29:25.909 +Você faz uma soma ponderada sobre dois índices k e l + +0:29:25.909,0:29:31.368 +E então você tem uma janela bidimensional indexada por k e l e calcula o produto escalar + +0:29:31.769,0:29:34.008 +daquela janela sobre X com o... + +0:29:35.099,0:29:39.679 +o peso, e isso lhe dá um valor em Yij que é a saída + +0:29:43.349,0:29:51.319 +Portanto, o vetor W ou a matriz W na versão 2d, há extensões óbvias disso para 3d e 4d, etc. + +0:29:52.080,0:29:55.639 +É chamado de kernel, é chamado de kernel convolucional, ok? + +0:30:00.380,0:30:03.309 +Está claro? Tenho certeza que isso é conhecido por muitos de vocês, mas... + +0:30:10.909,0:30:13.449 +Então, o que vamos fazer com isso é que + +0:30:14.750,0:30:18.699 +Vamos organizar... construir uma rede como uma sucessão de + +0:30:20.120,0:30:23.769 +convoluções onde em uma rede neural regular você tem + +0:30:25.340,0:30:29.100 +alternância de operadores lineares e não linearidade pontual + +0:30:29.250,0:30:34.389 +Em redes convolucionais, teremos uma alternância de operadores lineares que serão convoluções, então várias convoluções + +0:30:34.940,0:30:40.179 +Então também não linearidade pontual e haverá um terceiro tipo de operação chamado pooling... + +0:30:42.620,0:30:44.620 +que na verdade é opcional + +0:30:45.470,0:30:50.409 +Antes de prosseguir, devo mencionar que existem + +0:30:52.220,0:30:56.889 +torções que você pode fazer para esta convolução. Então uma torção é o que é chamado de passo + +0:30:57.380,0:31:01.239 +Assim, um passo em uma convolução consiste em mover a janela + +0:31:01.760,0:31:07.509 +de uma posição para outra em vez de movê-lo por apenas um valor + +0:31:07.940,0:31:13.510 +Você o move por dois ou três ou quatro, ok? Isso é chamado de passo de uma convolução + +0:31:14.149,0:31:17.138 +E então se você tem uma entrada de um certo comprimento e... + +0:31:19.700,0:31:26.590 +Então, digamos que você tenha uma entrada que é uma espécie de unidimensional e tamanho 100 cem + +0:31:27.019,0:31:31.059 +E você tem um kernel de convolução de tamanho cinco + +0:31:32.330,0:31:34.330 +Ok, e você se envolve + +0:31:34.909,0:31:38.409 +este kernel com a entrada + +0:31:39.350,0:31:46.120 +E você garante que a janela fique dentro da entrada de tamanho 100 + +0:31:46.730,0:31:51.639 +A saída que você obtém tem 96 saídas, ok? Tem o número de entradas + +0:31:52.519,0:31:56.019 +menos o tamanho do kernel, que é 5 menos 1 + +0:31:57.110,0:32:00.610 +Ok, isso dá 4. Então você obtém 100 menos 4, que é 96 + +0:32:02.299,0:32:08.709 +Esse é o número de janelas de tamanho 5 que cabem nessa grande entrada de tamanho 100 + +0:32:11.760,0:32:13.760 +Agora, se eu usar este passo... + +0:32:13.760,0:32:21.960 +Então, o que eu faço agora é pegar minha janela de 5 onde apliquei o kernel e desloco não por um pixel, mas por 2 pixels + +0:32:21.960,0:32:24.710 +Ou dois valores, digamos. Eles não são necessariamente pixels + +0:32:26.310,0:32:31.880 +Ok, o número de saídas que vou obter será dividido por dois aproximadamente + +0:32:33.570,0:32:36.500 +Ok, em vez de 96 eu vou ter + +0:32:37.080,0:32:42.949 +um pouco menos de 50, 48 ou algo assim. O número não é exato, você pode... + +0:32:44.400,0:32:46.400 +descobrir isso na sua cabeça + +0:32:47.430,0:32:51.470 +Muitas vezes, quando as pessoas executam convoluções em redes convolucionais, elas realmente preenchem a convolução + +0:32:51.470,0:32:59.089 +Então, às vezes, eles gostam de ter a saída do mesmo tamanho que a entrada e, na verdade, deslocam a janela de entrada + +0:32:59.490,0:33:02.479 +passado o final do vetor assumindo que é preenchido com zeros + +0:33:04.230,0:33:06.230 +geralmente dos dois lados + +0:33:16.110,0:33:19.849 +Tem algum efeito no desempenho ou é apenas por conveniência? + +0:33:21.480,0:33:25.849 +Se isso tem um efeito sobre o desempenho é ruim, ok? Mas é conveniente + +0:33:28.350,0:33:30.350 +Essa é praticamente a resposta + +0:33:32.700,0:33:37.800 +A suposição que é ruim é assumir que quando você não tem dados é igual a zero + +0:33:38.000,0:33:41.720 +Então, quando suas não linearidades são ReLU, não é necessariamente completamente irracional + +0:33:43.650,0:33:48.079 +Mas às vezes cria efeitos de borda engraçados (efeitos de fronteira) + +0:33:51.120,0:33:53.539 +Ok, tudo claro até agora? + +0:33:54.960,0:33:59.059 +Certo. OK. Então, o que vamos construir é um + +0:34:01.050,0:34:03.050 +rede neural composta por + +0:34:03.690,0:34:08.120 +convoluções que serão usadas como detectores de recursos, detectores de recursos locais + +0:34:09.090,0:34:13.069 +seguido por não linearidades, e então vamos empilhar várias camadas dessas + +0:34:14.190,0:34:18.169 +E a razão para empilhar várias camadas é porque + +0:34:19.170,0:34:21.090 +Nós queremos construir + +0:34:21.090,0:34:25.809 +representações hierárquicas do mundo visual dos dados + +0:34:26.089,0:34:32.258 +Não é... redes convolucionais não são necessariamente aplicadas a imagens. Eles podem ser aplicados à fala e outros sinais + +0:34:32.299,0:34:35.619 +Eles basicamente podem ser aplicados a qualquer sinal que chegue até você na forma de uma matriz + +0:34:36.889,0:34:41.738 +E eu vou voltar para as propriedades que este array tem que verificar + +0:34:43.789,0:34:45.789 +Então o que você quer é... + +0:34:46.459,0:34:48.698 +Por que você quer construir representações hierárquicas? + +0:34:48.699,0:34:54.369 +Porque o mundo é composicional - e eu aludi a isso, acho que a primeira palestra se lembra corretamente + +0:34:55.069,0:35:03.519 +É o fato de que os pixels se reúnem para formar motivos simples, como bordas orientadas + +0:35:04.430,0:35:10.839 +As arestas orientadas são montadas para formar recursos locais, como cantos e junções em T e ... + +0:35:11.539,0:35:14.018 +coisas assim... grades, você sabe, e... + +0:35:14.719,0:35:19.600 +em seguida, esses se reúnem para formar motivos um pouco mais abstratos. + +0:35:19.700,0:35:23.559 +Então, aqueles se reúnem para formar partes de objetos, e aqueles se reúnem para formar objetos + +0:35:23.559,0:35:28.000 +Portanto, há uma espécie de hierarquia de composição natural no mundo natural + +0:35:28.100,0:35:33.129 +E essa hierarquia de composição natural no mundo natural não é apenas por causa de + +0:35:34.369,0:35:38.438 +percepção --percepção visual-- é verdade em um nível físico, certo? + +0:35:41.390,0:35:46.808 +Você começa no nível mais baixo da descrição + +0:35:47.719,0:35:50.079 +Você tem partículas elementares e elas formam... + +0:35:50.079,0:35:56.438 +eles se aglomeram para formar partículas menos elementares, e se aglomeram para formar átomos, e se aglomeram para formar moléculas, e as moléculas se aglomeram para formar + +0:35:57.229,0:36:00.399 +materiais e materiais partes de objetos e + +0:36:01.130,0:36:03.609 +partes de objetos em objetos, e coisas assim, certo? + +0:36:04.670,0:36:07.599 +Ou macromoléculas ou polímeros, bla bla bla + +0:36:08.239,0:36:13.239 +E então você tem essa composição natural ou hierarquia, o mundo é construído dessa maneira + +0:36:14.719,0:36:19.000 +E pode ser por isso que o mundo é compreensível, certo? + +0:36:19.100,0:36:22.419 +Então há esta famosa citação de Einstein que diz: + +0:36:23.329,0:36:26.750 +"a coisa mais incompreensível sobre o mundo é que o mundo é compreensível" + +0:36:26.800,0:36:30.069 +E parece uma conspiração que vivemos em um mundo que somos capazes de compreender + +0:36:31.130,0:36:35.019 +Mas podemos compreendê-lo porque o mundo é composicional e + +0:36:36.970,0:36:38.970 +acontece de ser fácil de construir + +0:36:39.760,0:36:44.370 +cérebros em um mundo composicional que realmente pode interpretar o mundo composicional + +0:36:45.580,0:36:47.580 +Ainda me parece uma conspiração + +0:36:49.660,0:36:51.660 +Então, há uma frase famosa de... + +0:36:53.650,0:36:54.970 +a partir de um... + +0:36:54.970,0:37:00.780 +Não tão famoso, mas um tanto famoso, de um estatístico de Brown chamado Stuart Geman. + +0:37:01.360,0:37:04.799 +E ele diz que isso soa como uma conspiração, como mágica + +0:37:06.070,0:37:08.070 +Mas você sabe... + +0:37:08.440,0:37:15.570 +Se o mundo não fosse composicional, precisaríamos de ainda mais magia para poder entendê-lo + +0:37:17.260,0:37:21.540 +A maneira como ele diz isso é: "o mundo é composicional ou existe um Deus" + +0:37:25.390,0:37:32.339 +Você precisaria apelar para poderes superiores se o mundo não fosse composicional para explicar como podemos entendê-lo + +0:37:35.830,0:37:37.830 +Ok, então essa ideia de hierarquia + +0:37:38.440,0:37:44.520 +e a detecção de características locais vem da biologia. Portanto, toda a ideia de redes convolucionais vem da biologia. Tem sido + +0:37:45.850,0:37:47.850 +tão inspirado pela biologia e + +0:37:48.850,0:37:53.399 +o que você vê aqui à direita é um diagrama de Simon Thorpe, que é um + +0:37:54.160,0:37:56.160 +psicofísico e + +0:37:56.500,0:38:02.939 +fez alguns experimentos relativamente famosos onde mostrou que a maneira como reconhecemos objetos do cotidiano + +0:38:03.580,0:38:05.969 +parece ser extremamente rápido. Então se você mostrar... + +0:38:06.640,0:38:10.409 +se você mostrar a imagem de um objeto cotidiano para uma pessoa e + +0:38:11.110,0:38:12.730 +você pisca + +0:38:12.730,0:38:16.649 +um deles a cada 100 milissegundos mais ou menos, você percebe que o + +0:38:18.070,0:38:23.549 +o tempo que leva para uma pessoa identificar em uma longa sequência, se havia um objeto em particular, digamos um tigre + +0:38:25.780,0:38:27.640 +é cerca de 100 milissegundos + +0:38:27.640,0:38:34.769 +Portanto, o tempo que o cérebro leva para interpretar uma imagem e reconhecer objetos básicos nelas é de cerca de 100 milissegundos + +0:38:35.650,0:38:37.740 +Um décimo de segundo, certo? + +0:38:39.490,0:38:42.120 +E isso é quase o tempo que leva para o + +0:38:43.000,0:38:45.000 +sinal nervoso para se propagar + +0:38:45.700,0:38:47.550 +a retina + +0:38:47.550,0:38:54.090 +onde as imagens são formadas no olho para o que é chamado de LGN (núcleo geniculado lateral) + +0:38:54.340,0:38:56.340 +que é um pequeno + +0:38:56.350,0:39:02.640 +pedaço do cérebro que basicamente faz uma espécie de aprimoramento de contraste e ganha controle, e coisas assim + +0:39:03.580,0:39:08.789 +E então esse sinal vai para a parte de trás do seu cérebro v1. Essa é a área primária do córtex visual + +0:39:09.490,0:39:15.600 +em humanos e depois v2, que é muito próximo de v1. Há uma dobra que meio que faz a v1 meio que + +0:39:17.380,0:39:20.549 +bem na frente da v2, e há muitos fios entre eles + +0:39:21.580,0:39:28.890 +E então v4, e então o córtex temporal inferior, que está do lado aqui e é onde as categorias de objetos são representadas + +0:39:28.890,0:39:35.369 +Portanto, existem neurônios em seu córtex temporal inferior que representam categorias genéricas de objetos + +0:39:38.350,0:39:41.370 +E as pessoas fizeram experimentos com isso onde... + +0:39:44.320,0:39:51.150 +pacientes epilépticos estão no hospital e têm o crânio aberto porque precisam localizar o... + +0:39:52.570,0:40:00.200 +posição exata da fonte de suas crises de epilepsia + +0:40:02.080,0:40:04.650 +E porque eles têm eletrodos na superfície do cérebro + +0:40:05.770,0:40:11.000 +você pode mostrar os filmes e observar se um neurônio específico liga para filmes específicos + +0:40:11.100,0:40:14.110 +E você mostra a eles um filme com Jennifer Aniston e tem isso + +0:40:14.110,0:40:17.900 +neurônio que só liga quando Jennifer Aniston está lá, ok? + +0:40:18.000,0:40:21.000 +Ele não liga para mais nada até onde sabemos, ok? + +0:40:21.700,0:40:27.810 +Então você parece ter neurônios muito seletivos no córtex temporal inferior que reagem a um pequeno número de categorias + +0:40:30.760,0:40:35.669 +Há uma piada, uma espécie de piada corrente, na neurociência de um conceito chamado célula avó + +0:40:35.670,0:40:40.350 +Então este é o único neurônio em seu córtex temporal inferior que liga quando você vê sua avó + +0:40:41.050,0:40:45.120 +independentemente da posição que ela está vestindo, a que distância, se é uma foto ou não + +0:40:46.510,0:40:50.910 +Ninguém realmente acredita nesse conceito, o que as pessoas realmente acreditam são representações distribuídas + +0:40:50.910,0:40:54.449 +Então não existe celular que só liga pra sua avó + +0:40:54.970,0:41:00.820 +Há essa coleção de células que ligam para várias coisas e servem para representar categorias gerais + +0:41:01.100,0:41:04.060 +Mas o importante é que eles são invariáveis + +0:41:04.700,0:41:06.700 +posição, tamanho... + +0:41:06.920,0:41:11.080 +iluminação, todos os tipos de coisas diferentes e a verdadeira motivação por trás + +0:41:11.930,0:41:14.349 +redes convolucionais é construir + +0:41:15.140,0:41:18.670 +redes neurais que são invariantes à transformação irrelevante das entradas + +0:41:19.510,0:41:27.070 +Você ainda pode reconhecer um C ou D ou sua avó, independentemente da posição e, até certo ponto, da orientação, do estilo etc. + +0:41:29.150,0:41:36.790 +Então essa ideia de que o sinal leva apenas 100 milissegundos para ir da retina ao córtex temporal inferior + +0:41:37.160,0:41:40.330 +Parece sugerir que se você contar o atraso + +0:41:40.850,0:41:42.850 +passar por cada neurônio ou cada + +0:41:43.340,0:41:45.489 +fase nesse caminho + +0:41:46.370,0:41:48.880 +Mal há tempo suficiente para alguns picos passarem + +0:41:48.880,0:41:55.720 +Portanto, não há tempo para computação recorrente complexa, é basicamente um processo feed-forward. é muito rápido + +0:41:56.930,0:41:59.980 +Ok, e precisamos que seja rápido porque isso é uma questão de sobrevivência para nós + +0:41:59.980,0:42:06.159 +Há muito... para a maioria dos animais, você precisa ser capaz de reconhecer muito rapidamente o que está acontecendo, particularmente... + +0:42:07.850,0:42:12.820 +predadores ou presas em movimento rápido para esse assunto + +0:42:17.570,0:42:20.830 +Então, isso sugere a ideia de que podemos fazer + +0:42:21.920,0:42:26.230 +talvez possamos criar algum tipo de arquitetura de rede neuronal que seja completamente feed-forward e + +0:42:27.110,0:42:29.110 +ainda pode fazer o reconhecimento + +0:42:30.230,0:42:32.230 +O diagrama à direita + +0:42:34.430,0:42:39.280 +é de Gallent & Van Essen, então este é um tipo de resumo + +0:42:39.920,0:42:43.450 +diagrama conceitual das duas vias no córtex visual + +0:42:43.490,0:42:50.530 +Existe a via ventral e a via dorsal. O caminho ventral é basicamente a hierarquia v1, v2, v4, TI + +0:42:50.530,0:42:54.999 +que é meio que da parte de trás do cérebro, e vai para o fundo e para o lado e + +0:42:55.280,0:42:58.179 +então o caminho dorsal meio que vai + +0:42:59.060,0:43:02.469 +pelo topo também em direção ao córtex temporal inferior e + +0:43:04.040,0:43:09.619 +existe essa ideia de alguma forma que o caminho ventral está lá para dizer o que você está olhando, certo? + +0:43:10.290,0:43:12.499 +A via dorsal basicamente identifica + +0:43:13.200,0:43:15.200 +Localizações + +0:43:15.390,0:43:17.390 +geometria e movimento + +0:43:17.460,0:43:25.040 +OK? Portanto, há um caminho para o quê, e outro caminho para onde, e isso parece bastante separado no + +0:43:25.040,0:43:29.030 +córtex visual humano ou primata + +0:43:32.610,0:43:34.610 +E é claro que há interações entre eles + +0:43:39.390,0:43:45.499 +Então várias pessoas tiveram a ideia de usar... então de onde vem essa ideia? Há + +0:43:46.080,0:43:48.799 +trabalho clássico em neurociência do final dos anos 50 início dos anos 60 + +0:43:49.650,0:43:52.129 +Por Hubel & Wiesel, eles estão na foto aqui + +0:43:53.190,0:43:57.440 +Eles ganharam um Prêmio Nobel por isso, então é um trabalho realmente clássico e o que eles mostraram + +0:43:58.290,0:44:01.519 +com gatos --basicamente enfiando eletrodos em cérebros de gatos + +0:44:02.310,0:44:08.480 +é que os neurônios no cérebro do gato --em v1-- detectam... + +0:44:09.150,0:44:13.789 +são sensíveis apenas a uma pequena área do campo visual e detectam bordas orientadas + +0:44:14.970,0:44:17.030 +contornos nessa área em particular, ok? + +0:44:17.880,0:44:22.160 +Assim, a área à qual um neurônio em particular é sensível é chamada de campo receptivo. + +0:44:23.700,0:44:27.859 +E você pega um neurônio em particular e mostra + +0:44:29.070,0:44:35.719 +tipo de uma barra orientada que você gira, e em um ponto o neurônio irá disparar + +0:44:36.270,0:44:40.640 +para um determinado ângulo, e à medida que você se afasta desse ângulo, a ativação do neurônio + +0:44:42.690,0:44:50.149 +diminui, ok? Então isso é chamado de neurônios seletivos de orientação, e Hubel & Wiesel chamaram de células simples + +0:44:51.420,0:44:56.930 +Se você mover um pouco a barra, você sai do campo receptivo, aquele neurônio não dispara mais + +0:44:57.150,0:45:03.049 +não reage a isso. Este poderia ser outro neurônio quase exatamente idêntico a ele, apenas um pouco + +0:45:04.830,0:45:09.620 +Longe do primeiro que faz exatamente a mesma função. Ele vai reagir a um pouco diferente + +0:45:10.380,0:45:12.440 +campo receptivo, mas com a mesma orientação + +0:45:14.700,0:45:18.889 +Então você começa a ter essa ideia de que tem detectores de recursos locais posicionados + +0:45:20.220,0:45:23.689 +replicado por todo o campo visual, que é basicamente essa ideia de + +0:45:24.960,0:45:26.960 +convolução, ok? + +0:45:27.870,0:45:33.470 +Por isso são chamadas de células simples. E então outra ideia que ou descoberta que + +0:45:35.100,0:45:40.279 +Hubel & Wiesel fizeram é a ideia de células complexas. Então, o que é uma célula complexa é outro tipo de neurônio + +0:45:41.100,0:45:45.200 +que integra a saída de várias células simples dentro de uma determinada área + +0:45:46.170,0:45:50.120 +OK? Então eles vão pegar diferentes células simples que todas detectam + +0:45:51.180,0:45:54.079 +contornos em uma orientação específica, bordas em uma orientação específica + +0:45:55.350,0:46:02.240 +E calcule um agregado de todas essas ativações. Ele fará um máximo, ou uma soma, ou + +0:46:02.760,0:46:08.239 +uma soma de quadrados, ou raiz quadrada de soma de quadrados. Algum tipo de função que não depende da ordem dos argumentos + +0:46:08.820,0:46:11.630 +OK? Digamos max por uma questão de simplicidade + +0:46:12.900,0:46:17.839 +Então, basicamente, uma célula complexa será ativada se qualquer uma das células simples dentro de sua + +0:46:19.740,0:46:22.399 +grupo de entrada é ativado + +0:46:22.680,0:46:29.480 +OK? Assim, essa célula complexa detectará uma borda em uma orientação específica, independentemente de sua posição dentro dessa pequena região + +0:46:30.210,0:46:32.210 +Então ele constrói um pouco de + +0:46:32.460,0:46:34.609 +invariância de deslocamento do + +0:46:35.250,0:46:40.159 +representação que sai das células complexas com relação à pequena variação de posições de + +0:46:40.890,0:46:42.890 +características na entrada + +0:46:46.680,0:46:52.010 +Então, um cavalheiro com o nome de Kunihiko Fukushima + +0:46:54.420,0:46:56.569 +--Nenhuma relação real com a usina nuclear + +0:46:58.230,0:47:00.230 +No final dos anos 70 início dos anos 80 + +0:47:00.330,0:47:07.190 +experimentou com modelos de computador que meio que implementavam essa ideia de célula simples / célula complexa, e ele teve a ideia de replicar isso + +0:47:07.500,0:47:09.500 +com várias camadas, então basicamente... + +0:47:11.310,0:47:17.810 +A arquitetura que ele fez foi muito parecida com a que mostrei anteriormente aqui com esse tipo de artesanato + +0:47:18.570,0:47:20.490 +detector de recursos + +0:47:20.490,0:47:24.559 +Alguns desses detectores de recursos em seu modelo foram feitos à mão, mas alguns deles foram aprendidos + +0:47:25.230,0:47:30.709 +Eles foram aprendidos por um método não supervisionado. Ele não tinha backprop, certo? Backprop não existia + +0:47:30.710,0:47:36.770 +Quer dizer, existia, mas não era muito popular e as pessoas não o usavam + +0:47:38.609,0:47:43.338 +Então ele treinou esses filtros basicamente com algo que equivale a um + +0:47:44.190,0:47:46.760 +tipo de algoritmo de agrupamento um pouco ... + +0:47:49.830,0:47:53.569 +e separadamente para cada camada. E assim ele faria + +0:47:56.609,0:48:02.389 +treinar os filtros para a primeira camada, treinar isso com dígitos manuscritos -- ele também tinha um conjunto de dados de dígitos manuscritos + +0:48:03.390,0:48:06.470 +e, em seguida, alimentar isso para células complexas que + +0:48:06.470,0:48:10.820 +agrupar a atividade de células simples, e então isso + +0:48:11.880,0:48:18.440 +formar a entrada para a próxima camada, e repetiria o mesmo algoritmo em execução. Seu modelo de neurônio era muito complicado + +0:48:18.440,0:48:19.589 +Foi meio que inspirado pela biologia + +0:48:19.589,0:48:27.229 +Então tinha neurônios inibitórios separados, os outros neurônios só têm pesos positivos e pesos de saída, etc. + +0:48:27.839,0:48:29.839 +Ele conseguiu fazer essa coisa funcionar + +0:48:30.510,0:48:33.800 +Não muito bem, mas meio que funcionou + +0:48:36.420,0:48:39.170 +Então, alguns anos depois + +0:48:40.770,0:48:44.509 +Eu basicamente me inspirei em arquiteturas semelhantes, mas + +0:48:45.780,0:48:51.169 +treinou-os supervisionado com backprop, ok? Essa é a gênese das redes convolucionais, se você quiser + +0:48:51.750,0:48:53.869 +E então independentemente mais ou menos + +0:48:57.869,0:49:04.969 +O laboratório de Max Riesenhuber e Tony Poggio no MIT meio que redescobriu essa arquitetura também, mas também não usou backprop por algum motivo + +0:49:06.060,0:49:08.060 +Ele chama isso de H-max + +0:49:12.150,0:49:20.039 +Este é um tipo de experimento que fiz com redes convolucionais quando estava terminando meu pós-doutorado na Universidade de Toronto em 1988 + +0:49:20.040,0:49:22.040 +Então isso remonta a muito tempo + +0:49:22.840,0:49:26.730 +E eu estava tentando descobrir, isso funciona melhor em um pequeno conjunto de dados? + +0:49:26.730,0:49:27.870 +Então, se você tem uma pequena quantidade de dados + +0:49:27.870,0:49:31.109 +você está tentando se conectar totalmente à rede ou rede linear com apenas uma camada ou + +0:49:31.480,0:49:34.529 +uma rede com conexões locais, mas sem pesos compartilhados ou compare isso com + +0:49:35.170,0:49:39.299 +o que ainda não era chamado de rede convolucional, onde você compartilha pesos e conexões locais + +0:49:39.400,0:49:42.749 +Qual deles funciona melhor? E descobriu-se que em termos de + +0:49:43.450,0:49:46.439 +capacidade de generalização, que são as curvas no canto inferior esquerdo + +0:49:49.270,0:49:52.499 +que você vê aqui, a curva superior aqui, é... + +0:49:53.500,0:50:00.330 +basicamente a arquitetura de rede convolucional bebê treinada com um conjunto de dados muito simples de dígitos manuscritos que foram desenhados com um mouse, certo? + +0:50:00.330,0:50:02.490 +Não tínhamos como coletar imagens, basicamente + +0:50:03.640,0:50:05.640 +naquela hora + +0:50:05.860,0:50:09.240 +E então, se você tiver conexões reais sem pesos compartilhados + +0:50:09.240,0:50:12.119 +funciona um pouco pior. E então, se você estiver totalmente conectado + +0:50:14.470,0:50:22.230 +redes funciona pior, e se você tem uma rede linear, não só funciona pior, mas também superajusta, sobre trens + +0:50:23.110,0:50:28.410 +Então o erro de teste diminui depois de um tempo, e isso foi treinado com 320 + +0:50:29.410,0:50:35.519 +320 amostras de treinamento, o que é muito pequeno. Essas redes tiveram da ordem de + +0:50:36.760,0:50:43.170 +cinco mil conexões, mil parâmetros. Então isso é um bilhão de vezes menor do que o que fazemos hoje + +0:50:43.990,0:50:45.990 +Um milhão de vezes eu diria + +0:50:47.890,0:50:53.730 +E então terminei meu pós-doutorado, fui para a Bell Labs, e a Bell Labs tinha computadores um pouco maiores + +0:50:53.730,0:50:57.389 +mas o que eles tinham era um conjunto de dados que veio do Serviço Postal + +0:50:57.390,0:51:00.629 +Então eles tinham códigos postais para envelopes e nós construímos um + +0:51:00.730,0:51:05.159 +conjunto de dados desses códigos postais e, em seguida, treinou uma rede neural um pouco maior por três semanas + +0:51:06.430,0:51:12.749 +e obtive resultados muito bons. Portanto, esta rede convolucional não tem separação + +0:51:13.960,0:51:15.960 +convolução e agrupamento + +0:51:16.240,0:51:22.769 +Tinha convolução a passos largos, então convoluções onde a janela é deslocada em mais de um pixel. Então isso é... + +0:51:23.860,0:51:29.739 +Qual é o resultado disso? Então o resultado é que o mapa de saída quando você faz uma convolução onde o passo é + +0:51:30.710,0:51:36.369 +mais de um, você obtém uma saída cuja resolução é menor que a entrada e vê um exemplo aqui + +0:51:36.370,0:51:40.390 +Então aqui a entrada é de 16 por 16 pixels. Isso é o que poderíamos pagar + +0:51:41.900,0:51:49.029 +Os kernels são de 5 por 5, mas são deslocados em 2 pixels a cada vez e, portanto, o + +0:51:51.950,0:51:56.919 +a saída aqui é menor por causa disso + +0:52:11.130,0:52:13.980 +OK? E então um ano depois esta era a próxima geração + +0:52:14.830,0:52:16.830 +rede convolucional. Este tinha separado + +0:52:17.680,0:52:19.680 +convolução e pooling então... + +0:52:20.740,0:52:24.389 +Onde está a operação de pooling? Naquela época, a operação de pooling era apenas mais uma + +0:52:25.690,0:52:31.829 +neurônio exceto que todos os pesos desse neurônio eram iguais, ok? Assim, uma unidade de pooling era basicamente + +0:52:32.680,0:52:36.839 +uma unidade que calculou uma média de suas entradas + +0:52:37.180,0:52:41.730 +adicionou um viés e, em seguida, passou para uma não linearidade, que neste caso era uma função tangente hiperbólica + +0:52:42.820,0:52:48.450 +OK? Todas as não linearidades nesta rede eram tangentes hiperbólicas na época. Isso é o que as pessoas estavam fazendo + +0:52:53.200,0:52:55.200 +E a operação de agrupamento foi + +0:52:56.380,0:52:58.440 +realizado por deslocamento + +0:52:59.680,0:53:01.710 +a janela sobre a qual você calcula o + +0:53:02.770,0:53:09.240 +o agregado da saída da camada anterior por 2 pixels, ok? Então aqui + +0:53:10.090,0:53:13.470 +você obtém uma janela de entrada de 32 por 32 + +0:53:14.470,0:53:20.730 +Você envolve isso com filtros que são 5 por 5. Devo mencionar que um kernel de convolução às vezes também é chamado de filtro + +0:53:22.540,0:53:25.230 +E então o que você tem aqui são + +0:53:27.520,0:53:29.520 +saídas que são + +0:53:30.520,0:53:33.749 +Acho que menos 4, então é 28 por 28, ok? + +0:53:34.540,0:53:40.380 +E então há um pooling que calcula uma média de + +0:53:41.530,0:53:44.400 +pixels aqui em uma janela de 2 por 2 e + +0:53:45.310,0:53:47.310 +então muda essa janela por 2 + +0:53:48.160,0:53:50.160 +Então, quantas dessas janelas você tem? + +0:53:51.220,0:53:56.279 +Já que a imagem é 28 por 28, você divide por 2, é 14 por 14, ok? Então essas imagens + +0:53:57.460,0:54:00.359 +aqui estão 14 por 14 pixels + +0:54:02.050,0:54:05.759 +E eles são basicamente metade da resolução da janela anterior + +0:54:07.420,0:54:09.420 +por causa desse passo + +0:54:10.360,0:54:16.470 +OK? Agora fica interessante porque o que você quer é que a próxima camada detecte combinações de recursos da camada anterior + +0:54:17.200,0:54:19.200 +E assim... + +0:54:20.200,0:54:22.619 +a maneira de fazer isso é... você tem + +0:54:23.440,0:54:26.579 +diferentes filtros de convolução se aplicam a cada um desses mapas de recursos + +0:54:27.730,0:54:29.730 +OK? + +0:54:29.950,0:54:35.939 +E você os soma, soma os resultados dessas quatro circunvoluções e passa o resultado para uma não linearidade e isso lhe dá + +0:54:36.910,0:54:42.239 +um mapa de características da próxima camada. Então, porque esses filtros são 5 por 5 e aqueles + +0:54:43.330,0:54:46.380 +as imagens são 14 por 14, esses caras são 10 por 10 + +0:54:47.290,0:54:49.739 +OK? Para não ter efeitos de borda + +0:54:52.270,0:54:56.999 +Então, cada um desses mapas de recursos -- dos quais há dezesseis se bem me lembro + +0:54:59.290,0:55:01.290 +usa um conjunto diferente de + +0:55:02.860,0:55:04.860 +núcleos para... + +0:55:06.340,0:55:09.509 +convolva as camadas anteriores. Na verdade + +0:55:10.630,0:55:13.799 +o padrão de conexão entre o mapa de recursos... + +0:55:14.650,0:55:18.720 +o mapa de feição nesta camada e o mapa de feição na próxima camada não estão cheios + +0:55:18.720,0:55:22.349 +portanto, nem todo mapa de recursos está conectado a todos os mapas de recursos. Há um esquema particular de + +0:55:23.680,0:55:25.950 +diferentes combinações de mapa de recursos da camada anterior + +0:55:28.030,0:55:33.600 +combinando com quatro mapas de recursos na próxima camada. E a razão para fazer isso é apenas para economizar tempo no computador + +0:55:34.000,0:55:40.170 +Nós simplesmente não podíamos nos dar ao luxo de conectar tudo a tudo. Levaria o dobro do tempo para correr ou mais + +0:55:41.890,0:55:48.359 +Hoje em dia somos meio que forçados a ter uma conexão completa entre mapas de características em uma rede convolucional + +0:55:49.210,0:55:52.289 +Devido à maneira como várias convoluções são implementadas em GPUs + +0:55:53.440,0:55:55.440 +O que é triste + +0:55:56.560,0:55:59.789 +E então a próxima camada para cima. Então, novamente, esses mapas são 10 por 10 + +0:55:59.790,0:56:02.729 +Esses mapas de recursos são 10 por 10 e a próxima camada acima + +0:56:03.970,0:56:06.389 +é produzido por agrupamento e subamostragem + +0:56:07.330,0:56:09.330 +por um fator de 2 + +0:56:09.370,0:56:11.370 +e então esses são 5 por 5 + +0:56:12.070,0:56:14.880 +OK? E então, novamente, há uma convolução de 5 por 5 aqui + +0:56:14.880,0:56:18.089 +Claro, você não pode mover a janela 5 por 5 sobre uma imagem de 5 por 5 + +0:56:18.090,0:56:21.120 +Parece uma conexão completa, mas na verdade é uma convolução + +0:56:22.000,0:56:24.000 +OK? Mantenha isso em mente + +0:56:24.460,0:56:26.460 +Mas você basicamente apenas soma em apenas um local + +0:56:27.250,0:56:33.960 +E esses mapas de recursos no topo aqui são realmente saídas. E assim você tem um local especial + +0:56:33.960,0:56:39.399 +OK? Porque você só pode colocar uma janela de 5 por 5 em uma imagem de 5 por 5 + +0:56:40.460,0:56:45.340 +E você tem 10 desses mapas de recursos, cada um correspondendo a uma categoria, então você treina o sistema para classificar + +0:56:45.560,0:56:47.619 +dígitos de 0 a 9, você tem dez categorias + +0:56:59.750,0:57:03.850 +Esta é uma pequena animação que peguei emprestada de Andrej Karpathy + +0:57:05.570,0:57:08.439 +Ele gastou o tempo para construir esta animação real muito legal + +0:57:09.470,0:57:16.780 +que é para representar várias circunvoluções, certo? Então você tem três mapas de recursos aqui na entrada e você tem seis + +0:57:18.650,0:57:21.100 +kernels de convolução e dois mapas de recursos na saída + +0:57:21.100,0:57:26.709 +Então, aqui o primeiro grupo de três mapas de recursos é convoluído com... + +0:57:28.520,0:57:31.899 +kernels são convolvidos com os três mapas de recursos de entrada para produzir + +0:57:32.450,0:57:37.330 +o primeiro grupo, o primeiro dos dois mapas de recursos, o verde no topo + +0:57:38.390,0:57:40.370 +OK? + +0:57:40.370,0:57:42.820 +E então... + +0:57:44.180,0:57:49.000 +Ok, então este é o primeiro grupo de três kernels convoluídos com os três mapas de recursos + +0:57:49.000,0:57:53.349 +E eles produzem o mapa verde no topo, e então você muda para o segundo grupo de + +0:57:54.740,0:57:58.479 +de núcleos de convolução. Você se envolve com o + +0:57:59.180,0:58:04.149 +três mapas de recursos de entrada para produzir o mapa na parte inferior. OK? Então isso é + +0:58:05.810,0:58:07.810 +um exemplo de + +0:58:10.070,0:58:17.709 +Mapa de n recursos na entrada, mapa de n recursos na saída e N vezes M kernels de convolução para obter todas as combinações + +0:58:25.000,0:58:27.000 +Aqui está outra animação que fiz há muito tempo + +0:58:28.100,0:58:34.419 +Isso mostra a rede convolucional depois de ser treinada em ação tentando reconhecer dígitos + +0:58:35.330,0:58:38.529 +E o que é interessante ver aqui é que você tem + +0:58:39.440,0:58:41.440 +uma entrada aqui, que é eu acredito + +0:58:42.080,0:58:44.590 +32 linhas por 64 colunas + +0:58:45.770,0:58:52.570 +E depois de fazer seis convoluções com seis núcleos de convolução passando por uma tangente hiperbólica não linear após um viés + +0:58:52.570,0:58:59.229 +você obtém esses mapas de recursos aqui, cada um dos quais é ativado para um tipo diferente de recurso. Assim, por exemplo + +0:58:59.990,0:59:01.990 +o mapa de recursos no topo aqui + +0:59:02.390,0:59:04.690 +acende quando há algum tipo de borda horizontal + +0:59:07.400,0:59:10.090 +Esse cara aqui liga sempre que tem uma borda vertical + +0:59:10.940,0:59:15.340 +OK? E esses kernels convolucionais foram aprendidos através do backprop, a coisa acabou de ser treinada + +0:59:15.980,0:59:20.980 +com suporte traseiro. Não definido à mão. Eles são definidos aleatoriamente geralmente + +0:59:21.620,0:59:26.769 +Então você vê essa noção de equivariância aqui, se eu mudar a imagem de entrada + +0:59:27.500,0:59:31.600 +as ativações nos mapas de recursos mudam, mas permanecem inalteradas + +0:59:32.540,0:59:34.540 +Tudo bem? + +0:59:34.940,0:59:36.940 +Isso é equivariância de deslocamento + +0:59:36.950,0:59:38.860 +Ok, e então vamos para a operação de pooling + +0:59:38.860,0:59:42.519 +Portanto, este primeiro mapa de recursos aqui corresponde a uma versão agrupada de + +0:59:42.800,0:59:46.149 +este primeiro, o segundo para o segundo, o terceiro foi para o terceiro + +0:59:46.250,0:59:51.370 +e a operação de agrupamento aqui novamente é uma média, depois um viés, depois uma não linearidade semelhante + +0:59:52.070,0:59:55.029 +E assim, se este mapa muda de + +0:59:56.570,0:59:59.499 +um pixel este mapa mudará em meio pixel + +0:00:01.370,0:00:02.780 +OK? + +0:00:02.780,0:00:05.259 +Então você ainda tem equavariância, mas + +0:00:06.260,0:00:11.830 +os deslocamentos são reduzidos por um fator de dois, essencialmente + +0:00:11.830,0:00:15.850 +e então você tem o segundo estágio onde cada um desses mapas aqui é resultado de + +0:00:16.160,0:00:23.440 +fazendo uma convolução em cada um, ou um subconjunto dos mapas anteriores com kernels diferentes, somando o resultado, passando o resultado por + +0:00:24.170,0:00:27.070 +um sigmóide, e assim você obtém esse tipo de recursos abstratos + +0:00:28.730,0:00:32.889 +aqui que são um pouco difíceis de interpretar visualmente, mas ainda é equivalente mudar + +0:00:33.860,0:00:40.439 +OK? E então, novamente, você faz o agrupamento e a subamostragem. Então o pooling também tem esse passo por um fator de dois + +0:00:40.630,0:00:42.580 +Então o que você tem aqui são + +0:00:42.580,0:00:47.609 +nossos mapas, para que esses mapas mudem em um quarto de pixel se a entrada mudar em um pixel + +0:00:48.730,0:00:55.290 +OK? Então reduzimos a mudança e torna-se... pode tornar-se cada vez mais fácil para as camadas seguintes para interpretar qual é a forma + +0:00:55.290,0:00:57.290 +porque você troca + +0:00:58.540,0:01:00.540 +resolução espacial para + +0:01:01.030,0:01:05.009 +resolução do tipo de recurso. Você aumenta o número de tipos de feição à medida que sobe as camadas + +0:01:06.040,0:01:08.879 +A resolução espacial diminui devido ao agrupamento e subamostragem + +0:01:09.730,0:01:14.459 +Mas o número de mapas de recursos aumenta e você torna a representação um pouco mais abstrata + +0:01:14.460,0:01:19.290 +mas menos sensível a mudanças e distorções. E a próxima camada + +0:01:20.740,0:01:25.080 +novamente executa convoluções, mas agora o tamanho do kernel de convolução é igual à altura da imagem + +0:01:25.080,0:01:27.449 +E então o que você ganha é uma única banda + +0:01:28.359,0:01:32.219 +para este mapa de recursos. Basicamente torna-se unidimensional e + +0:01:32.920,0:01:39.750 +então agora qualquer deslocamento vertical é basicamente eliminado, certo? Ele se transformou em alguma variação de ativação, mas não é + +0:01:40.840,0:01:42.929 +Não é mais uma mudança. É algum tipo de + +0:01:44.020,0:01:45.910 +mais simples --espero + +0:01:45.910,0:01:49.020 +transformação da entrada. Na verdade, você pode mostrar que é mais simples + +0:01:51.160,0:01:53.580 +É mais plano em alguns aspectos + +0:01:56.650,0:02:00.330 +OK? Esse é o tipo de arquitetura de rede convolucional genérica que temos + +0:02:01.570,0:02:05.699 +Esta é uma versão um pouco mais moderna, onde você tem alguma forma de normalização + +0:02:07.450,0:02:09.450 +Norma de lote + +0:02:10.600,0:02:15.179 +Boa norma, tanto faz. Um banco de filtros, essas são as múltiplas convoluções + +0:02:16.660,0:02:18.690 +No processamento de sinal, eles são chamados de bancos de filtros + +0:02:19.840,0:02:27.149 +Não linearidade pontual, geralmente um ReLU e, em seguida, algum pooling, geralmente max pooling no mais comum + +0:02:28.330,0:02:30.629 +implementações de redes convolucionais. Você pode, claro + +0:02:30.630,0:02:35.880 +imagine outros tipos de pooling. Eu falei sobre a média, mas a versão mais genérica é a norma LP + +0:02:36.640,0:02:38.640 +qual é... + +0:02:38.770,0:02:45.530 +pegue todas as entradas através de uma célula complexa, eleve-as a alguma potência e então pegue o... + +0:02:45.530,0:02:47.530 +Soma-os e depois toma o... + +0:02:49.860,0:02:51.860 +Eleve isso para 1 sobre o poder + +0:02:53.340,0:02:58.489 +Sim, isso deve ser uma soma dentro da raiz P-th aqui + +0:03:00.870,0:03:02.870 +Outra maneira de piscina e novamente + +0:03:03.840,0:03:07.759 +uma boa operação de pooling é uma operação que é + +0:03:07.920,0:03:11.719 +invariante a uma permutação da entrada. Dá o mesmo resultado + +0:03:12.750,0:03:14.750 +independentemente da ordem em que você coloca a entrada + +0:03:15.780,0:03:22.670 +Aqui está outro exemplo. Falamos sobre essa função antes: 1 sobre b log soma de nossas entradas de e para o bXᵢ + +0:03:25.920,0:03:30.649 +Exponencial bX. Novamente, esse é um tipo de operação de agregação simétrica que você pode usar + +0:03:32.400,0:03:35.539 +Então, isso é uma espécie de estágio de uma rede convolucional, e então você pode repetir isso + +0:03:36.270,0:03:43.729 +Existem várias maneiras de posicionar a normalização. Algumas pessoas colocam após a não linearidade antes do agrupamento + +0:03:43.730,0:03:45.730 +Você sabe, depende + +0:03:46.590,0:03:48.590 +Mas é típico + +0:03:53.640,0:03:56.569 +Então, como você faz isso no PyTorch? há várias maneiras diferentes + +0:03:56.570,0:04:02.479 +Você pode fazer isso escrevendo explicitamente, escrevendo uma classe. Este é um exemplo de uma classe de rede convolucional + +0:04:04.020,0:04:10.520 +Em particular aqui onde você faz convoluções, ReLU e pool máximo + +0:04:12.600,0:04:17.900 +Ok, então o construtor aqui cria camadas convolucionais que possuem parâmetros nelas + +0:04:18.810,0:04:24.499 +E este tem o que chamamos de camadas totalmente conectadas. Eu odeio isso. OK? + +0:04:25.980,0:04:30.919 +Então existe essa ideia de alguma forma que a última camada de uma rede convolucional + +0:04:32.760,0:04:34.790 +Como este, está totalmente conectado porque + +0:04:37.320,0:04:42.860 +cada unidade nesta camada está conectada a cada unidade naquela camada. Então isso parece uma conexão completa + +0:04:44.010,0:04:47.060 +Mas é realmente útil pensar nisso como uma convolução + +0:04:49.200,0:04:51.060 +OK? + +0:04:51.060,0:04:56.070 +Agora, por razões de eficiência, ou talvez outras razões ruins, eles são chamados + +0:04:57.370,0:05:00.959 +camadas totalmente conectadas, e usamos a classe linear aqui + +0:05:01.120,0:05:05.459 +Mas meio que quebra toda a ideia de que sua rede é uma rede convolucional + +0:05:06.070,0:05:09.209 +Portanto, é muito melhor vê-los como convoluções + +0:05:09.760,0:05:14.370 +Neste caso, uma por uma convolução que é uma espécie de conceito estranho. OK. Então aqui temos + +0:05:15.190,0:05:20.460 +quatro camadas, duas camadas convolucionais e duas chamadas camadas totalmente conectadas + +0:05:21.790,0:05:23.440 +E então a maneira como nós... + +0:05:23.440,0:05:29.129 +Então, precisamos criá-los no construtor, e a maneira como os usamos na passagem para frente é que + +0:05:30.630,0:05:35.310 +nós fazemos uma convolução da entrada, e então aplicamos o ReLU, e então fazemos o pool máximo e então nós + +0:05:35.710,0:05:38.699 +execute a segunda camada e aplique o ReLU e faça o pool máximo novamente + +0:05:38.700,0:05:44.280 +E então remodelamos a saída porque é uma camada totalmente conectada. Então queremos fazer disso um + +0:05:45.190,0:05:47.879 +vetor então é isso que o x.view(-1) faz + +0:05:48.820,0:05:50.820 +E depois aplique um + +0:05:51.160,0:05:53.160 +ReLU para isso + +0:05:53.260,0:05:55.260 +E... + +0:05:55.510,0:06:00.330 +a segunda camada totalmente conectada e, em seguida, aplique um softmax se quisermos fazer a classificação + +0:06:00.460,0:06:04.409 +E isso é um pouco semelhante à arquitetura que você vê na parte inferior + +0:06:04.900,0:06:08.370 +Os números podem ser diferentes em termos de mapas de recursos e outras coisas, mas ... + +0:06:09.160,0:06:11.160 +mas a arquitetura geral é + +0:06:12.250,0:06:14.250 +praticamente o que estamos falando + +0:06:15.640,0:06:17.640 +Sim? + +0:06:20.530,0:06:22.530 +Repita + +0:06:24.040,0:06:26.100 +Você sabe, o que quer que a descida do gradiente decida + +0:06:28.630,0:06:30.630 +Podemos olhar para eles, mas + +0:06:31.180,0:06:33.180 +se você treinar com muito + +0:06:33.280,0:06:37.590 +exemplos de imagens naturais, o tipo de filtro que você verá na primeira camada + +0:06:37.840,0:06:44.999 +basicamente acabarão sendo detectores de bordas orientados, muito semelhantes ao que as pessoas, ao que os neurocientistas + +0:06:45.340,0:06:49.110 +observar no córtex de + +0:06:49.210,0:06:50.440 +animais + +0:06:50.440,0:06:52.440 +No córtex visual dos animais + +0:06:55.780,0:06:58.469 +Eles vão mudar quando você treinar o modelo, esse é o ponto sim + +0:07:05.410,0:07:11.160 +Ok, então é bem simples. Aqui está outra maneira de defini-los. Isso é... eu acho que é uma espécie de + +0:07:12.550,0:07:15.629 +maneira desatualizada de fazer isso, certo? Muitas pessoas não fazem mais isso + +0:07:17.170,0:07:23.340 +mas é uma forma simples. Também existe essa classe no PyTorch chamada nn.Sequential + +0:07:24.550,0:07:28.469 +É basicamente um container e você continua colocando módulos nele e simplesmente + +0:07:29.080,0:07:36.269 +automaticamente meio que usá-los como sendo meio conectados em sequência, certo? E então você só tem que ligar + +0:07:40.780,0:07:45.269 +adiante e ele apenas calculará a coisa certa + +0:07:46.360,0:07:50.370 +Neste formulário específico aqui, você passa um monte de pares + +0:07:50.370,0:07:55.229 +É como um dicionário para que você possa dar um nome a cada uma das camadas e depois acessá-las + +0:08:08.079,0:08:10.079 +É a mesma arquitetura que estávamos falando anteriormente + +0:08:18.489,0:08:24.029 +Sim, quero dizer que o backprop é automático, certo? Você entendeu + +0:08:25.630,0:08:27.630 +por padrão você apenas chama + +0:08:28.690,0:08:32.040 +para trás e sabe como voltar a propagar através dele + +0:08:44.000,0:08:49.180 +Bem, a classe meio que encapsula tudo em um objeto onde os parâmetros são + +0:08:49.250,0:08:51.250 +Existe uma forma específica de... + +0:08:52.220,0:08:54.220 +tirando os parâmetros e + +0:08:55.130,0:08:58.420 +tipo de alimentá-los para um otimizador + +0:08:58.420,0:09:01.330 +E assim o otimizador não precisa saber como é sua rede + +0:09:01.330,0:09:06.910 +Ele apenas sabe que existe uma função e um monte de parâmetros e obtém um gradiente e + +0:09:06.910,0:09:08.910 +ele não precisa saber como é sua rede + +0:09:10.790,0:09:12.879 +Sim, você vai ouvir mais sobre isso + +0:09:14.840,0:09:16.840 +amanhã + +0:09:25.610,0:09:33.159 +Então aqui está um aspecto muito interessante das redes convolucionais e é uma das razões pelas quais elas se tornaram tão + +0:09:33.830,0:09:37.390 +sucesso em muitas aplicações. É o fato de + +0:09:39.440,0:09:45.280 +se você visualizar cada camada em uma rede convolucional como uma convolução, então não há conexões completas, por assim dizer + +0:09:47.660,0:09:53.320 +você não precisa ter uma entrada de tamanho fixo. Você pode variar o tamanho da entrada e a rede + +0:09:54.380,0:09:56.380 +variar seu tamanho de acordo + +0:09:56.780,0:09:58.780 +Porque... + +0:09:59.510,0:10:01.510 +quando você aplica uma convolução a uma imagem + +0:10:02.150,0:10:05.800 +você encaixa uma imagem de um certo tamanho, você faz uma convolução com um kernel + +0:10:06.620,0:10:11.979 +você obtém uma imagem cujo tamanho está relacionado ao tamanho da entrada + +0:10:12.140,0:10:15.789 +mas você pode alterar o tamanho da entrada e apenas altera o tamanho da saída + +0:10:16.760,0:10:20.320 +E isso é verdade para todas as operações do tipo convolucional, certo? + +0:10:20.320,0:10:25.509 +Portanto, se sua rede é composta apenas de convoluções, não importa o tamanho da entrada + +0:10:26.180,0:10:31.450 +Vai passar pela rede e o tamanho de cada camada mudará de acordo com o tamanho da entrada + +0:10:31.580,0:10:34.120 +e o tamanho da saída também mudará de acordo + +0:10:34.640,0:10:37.329 +Então aqui está um pequeno exemplo aqui onde + +0:10:38.720,0:10:40.720 +Eu quero fazer + +0:10:41.300,0:10:45.729 +reconhecimento de caligrafia cursiva e é muito difícil porque não sei onde estão as letras + +0:10:45.730,0:10:48.700 +Então eu não posso simplesmente ter um reconhecedor de caracteres que... + +0:10:49.260,0:10:51.980 +Refiro-me a um sistema que primeiro cortará o + +0:10:52.890,0:10:56.100 +palavra em letras + +0:10:56.100,0:10:57.720 +porque não sei onde estão as letras + +0:10:57.720,0:10:59.900 +e, em seguida, aplique a rede convolucional a cada uma das letras + +0:11:00.210,0:11:05.200 +Então, o melhor que posso fazer é pegar a rede convolucional e passá-la sobre a entrada e gravar a saída + +0:11:05.850,0:11:11.810 +OK? E então você pensaria que para fazer isso você terá que pegar uma rede convolucional como esta que tem uma janela + +0:11:12.060,0:11:14.389 +grande o suficiente para ver um único caractere + +0:11:15.120,0:11:21.050 +e então você pega sua imagem de entrada e calcula sua rede convolucional em cada local + +0:11:21.660,0:11:27.110 +deslocando-o em um pixel ou dois pixels ou quatro pixels ou algo assim, um número pequeno o suficiente de pixels que + +0:11:27.630,0:11:30.619 +independentemente de onde o caractere ocorre na entrada + +0:11:30.620,0:11:35.000 +você ainda obterá uma pontuação na saída sempre que precisar reconhecer um + +0:11:36.150,0:11:38.989 +Mas acontece que será extremamente desperdício + +0:11:40.770,0:11:42.770 +Porque... + +0:11:43.290,0:11:50.179 +você estará refazendo o mesmo cálculo várias vezes. E a maneira correta de fazer isso -- e isso é muito importante para entender + +0:11:50.880,0:11:56.659 +é que você não faz o que acabei de descrever onde você tem uma pequena rede convolucional que você aplica a todas as janelas + +0:11:58.050,0:12:00.050 +O que você faz é você + +0:12:01.230,0:12:07.939 +pegue uma entrada grande e aplique as convoluções à imagem de entrada, pois é maior, você obterá uma saída maior + +0:12:07.940,0:12:11.270 +você aplica a convolução da segunda camada a isso, ou o pooling, seja lá o que for + +0:12:11.610,0:12:15.170 +Você obterá uma entrada maior novamente, etc. + +0:12:15.170,0:12:16.650 +todo o caminho até o topo e + +0:12:16.650,0:12:20.929 +enquanto no design original você estava obtendo apenas uma saída, agora você obterá várias saídas porque + +0:12:21.570,0:12:23.570 +é uma camada convolucional + +0:12:27.990,0:12:29.990 +Isso é superimportante porque + +0:12:30.600,0:12:35.780 +esta maneira de aplicar uma rede convolucional com uma janela deslizante é + +0:12:36.870,0:12:40.610 +muito, muito mais barato do que recalcular a rede convolucional em cada local + +0:12:42.510,0:12:44.510 +OK? + +0:12:45.150,0:12:51.619 +Você não acreditaria em quantas décadas foram necessárias para convencer as pessoas de que isso era uma coisa boa + +0:12:58.960,0:13:03.390 +Então aqui está um exemplo de como você pode usar isso + +0:13:04.090,0:13:09.180 +Esta é uma rede convencional que foi treinada em dígitos individuais, 32 por 32. Foi treinada em um MNIST, ok? + +0:13:09.760,0:13:11.760 +32 por 32 janelas de entrada + +0:13:12.400,0:13:15.690 +É LeNet 5, então é muito semelhante à arquitetura + +0:13:15.690,0:13:20.940 +Acabei de mostrar o código para, ok? É treinado em personagens individuais para apenas classificar + +0:13:21.970,0:13:26.369 +o personagem no centro da imagem. E a maneira como foi treinado foi que havia um pouco de dados + +0:13:26.770,0:13:30.359 +aumento onde o personagem no centro foi meio que mudou um pouco em vários locais + +0:13:31.420,0:13:36.629 +mudou de tamanho. E então havia dois outros personagens + +0:13:37.420,0:13:39.600 +que foram meio que adicionados ao lado para confundir + +0:13:40.480,0:13:45.660 +em muitas amostras. E então também foi treinado com uma 11ª categoria + +0:13:45.660,0:13:50.249 +que foi "nenhuma das opções acima" e a maneira como é treinado é ou você mostra uma imagem em branco + +0:13:50.410,0:13:54.149 +ou você mostra uma imagem onde não há nenhum caractere no centro, mas há caracteres na lateral + +0:13:54.940,0:13:59.399 +para detectar sempre que estiver entre dois caracteres + +0:14:00.520,0:14:02.520 +e então você faz essa coisa de + +0:14:02.650,0:14:10.970 +computando a rede convolucional em cada local na entrada sem realmente deslocá-la, mas apenas aplicando as convoluções à imagem inteira + +0:14:11.740,0:14:13.740 +E é isso que você ganha + +0:14:13.780,0:14:23.220 +Então aqui a imagem de entrada é 64 por 32, embora a rede tenha sido treinada em 32 por 32 com esse tipo de exemplo gerado + +0:14:24.280,0:14:28.049 +E o que você vê é a atividade de algumas das camadas, nem todas estão representadas + +0:14:29.410,0:14:32.309 +E o que você vê no topo aqui, essas formas engraçadas + +0:14:33.520,0:14:37.560 +Você vê três e cinco aparecendo e eles são basicamente um + +0:14:38.830,0:14:41.850 +indicação da categoria vencedora para cada localidade, certo? + +0:14:42.670,0:14:47.339 +Portanto, as oito saídas que você vê no topo são + +0:14:48.520,0:14:50.520 +basicamente a saída correspondente a oito + +0:14:51.250,0:14:56.790 +posições da janela de entrada de 32 por 32 na entrada, deslocadas em 4 pixels a cada vez + +0:14:59.530,0:15:05.859 +E o que está representado é a categoria vencedora dentro dessa janela e a escala de cinza indica a pontuação, ok? + +0:15:07.220,0:15:10.419 +Então o que você vê é que há dois detectores detectando os cinco + +0:15:11.030,0:15:15.850 +até que os três tipos comecem a se sobrepor. E então dois detectores estão detectando os três que meio que se moveram + +0:15:18.230,0:15:22.779 +porque dentro de uma janela de 32 por 32 + +0:15:23.390,0:15:29.919 +os três aparecem à esquerda dessa janela de 32 por 32 e, em seguida, à direita das outras janelas de 32 por 32 deslocadas por quatro + +0:15:29.920,0:15:31.920 +e então esses dois detectores detectam + +0:15:32.690,0:15:34.690 +aquele 3 ou aquele 5 + +0:15:36.140,0:15:39.890 +Então o que você faz é pegar todas essas pontuações aqui no topo e você + +0:15:39.890,0:15:43.809 +faça um pouco de pós-processamento muito simples e você descobre se é um três e um cinco + +0:15:44.630,0:15:46.630 +O que é interessante nisso é que + +0:15:47.660,0:15:49.899 +você não precisa fazer segmentação prévia + +0:15:49.900,0:15:51.860 +Então, algo que as pessoas tinham que fazer + +0:15:51.860,0:15:58.180 +antes, em visão computacional, era se você quisesse reconhecer um objeto que você tinha que separar o objeto de seu fundo porque o sistema de reconhecimento + +0:15:58.490,0:16:00.490 +ficaria confuso com + +0:16:00.800,0:16:07.900 +o fundo. Mas aqui com esta rede convolucional, ela foi treinada com caracteres sobrepostos e sabe como diferenciá-los + +0:16:08.600,0:16:10.809 +E por isso não é confundido por caracteres que se sobrepõem + +0:16:10.810,0:16:15.729 +Eu tenho um monte deles no meu site, a propósito, aquelas animações do início dos anos noventa + +0:16:38.450,0:16:41.679 +Não, essa era a questão principal. Essa é uma das razões pelas quais + +0:16:44.210,0:16:48.040 +a visão computacional não estava funcionando muito bem. É porque o próprio problema de + +0:16:49.850,0:16:52.539 +separação figura/fundo, detectando um objeto + +0:16:53.780,0:16:59.530 +e reconhecê-lo é o mesmo. Você não pode reconhecer o objeto até segmentá-lo, mas não pode segmentá-lo até reconhecê-lo + +0:16:59.840,0:17:05.290 +É o mesmo para o reconhecimento de caligrafia cursiva, certo? Você não pode... então aqui está um exemplo + +0:17:07.460,0:17:09.460 +Temos canetas? + +0:17:10.650,0:17:12.650 +Não parece que temos canetas né? + +0:17:14.969,0:17:21.859 +Aqui vamos nós, isso é verdade. Me desculpe... talvez eu deva usar o... + +0:17:24.780,0:17:26.780 +Se isso funcionar... + +0:17:34.500,0:17:36.510 +Ah, claro... + +0:17:43.409,0:17:45.409 +OK... + +0:17:52.310,0:17:54.310 +Vocês podem ler isso? + +0:17:55.670,0:18:01.990 +Ok, quero dizer que é uma caligrafia horrível, mas também é porque estou escrevendo na tela. Ok, agora você pode lê-lo? + +0:18:08.240,0:18:10.240 +Mínimo sim + +0:18:11.870,0:18:15.010 +Ok, na verdade não há como você segmentar as letras dessa direita + +0:18:15.010,0:18:17.439 +Quero dizer, isso é meio que um número aleatório de ondas + +0:18:17.900,0:18:23.260 +Mas apenas o fato de que os dois "I"s são identificados, então basicamente não é ambíguo, pelo menos em inglês + +0:18:24.620,0:18:26.620 +Então esse é um bom exemplo de + +0:18:28.100,0:18:30.340 +a interpretação do indivíduo + +0:18:31.580,0:18:38.169 +objetos dependendo de seu contexto. E o que você precisa é de algum tipo de modelo de linguagem de alto nível para saber quais palavras são possíveis + +0:18:38.170,0:18:40.170 +Se você não sabe inglês ou similar + +0:18:40.670,0:18:44.320 +idiomas que têm a mesma palavra, não tem como você ler isso + +0:18:45.500,0:18:48.490 +A linguagem falada é muito semelhante a esta + +0:18:49.700,0:18:53.679 +Todos vocês que tiveram a experiência de aprender uma língua estrangeira + +0:18:54.470,0:18:56.470 +provavelmente teve a experiência de que + +0:18:57.110,0:19:04.150 +você tem dificuldade em segmentar palavras de um novo idioma e depois reconhecer as palavras porque não tem o vocabulário + +0:19:04.850,0:19:09.550 +Certo? Então, se eu falar em francês -- se eu começar a falar francês, você não tem ideia de onde estão os limites das palavras] + +0:19:09.740,0:19:13.749 +Exceto se você fala francês. Então eu falei uma frase, são palavras + +0:19:13.750,0:19:17.140 +mas você não pode dizer o limite entre as palavras porque basicamente não é + +0:19:17.990,0:19:23.800 +clara apreensão entre as palavras, a menos que você saiba onde as palavras estão de antemão, certo? Então esse é o problema da segmentação + +0:19:23.900,0:19:28.540 +Você não pode reconhecer até segmentar, não pode segmentar até reconhecer que precisa fazer as duas coisas ao mesmo tempo + +0:19:29.150,0:19:32.379 +Os primeiros sistemas de visão computacional tiveram muita dificuldade em fazer isso + +0:19:40.870,0:19:46.739 +Então é por isso que esse tipo de coisa é um grande progresso, porque você não precisa fazer a segmentação com antecedência, apenas... + +0:19:47.679,0:19:52.559 +apenas treine seu sistema para ser robusto a objetos sobrepostos e coisas assim. Sim, nas costas! + +0:19:55.510,0:19:59.489 +Sim, há uma classe de fundo. Então, quando você vê uma resposta em branco + +0:20:00.340,0:20:04.410 +significa que o sistema diz "nenhuma das opções acima" basicamente, certo? Então foi treinado + +0:20:05.590,0:20:07.590 +para produzir "nenhuma das anteriores" + +0:20:07.690,0:20:11.699 +ou quando a entrada está em branco ou quando há um caractere que é muito + +0:20:13.420,0:20:17.190 +fora do centro ou quando você tem dois personagens + +0:20:17.620,0:20:24.029 +mas não há nada no centro. Ou quando você tem dois personagens que se sobrepõem, mas não tem um personagem central, certo? Então é... + +0:20:24.760,0:20:27.239 +tentando detectar limites entre personagens essencialmente + +0:20:28.420,0:20:30.420 +Aqui está outro exemplo + +0:20:31.390,0:20:38.640 +Este é um exemplo que mostra que mesmo uma rede convolucional muito simples com apenas dois estágios, certo? convolução, agrupamento, convolução + +0:20:38.640,0:20:40.640 +pooling e, em seguida, duas camadas de ... + +0:20:42.010,0:20:44.010 +mais duas camadas depois + +0:20:44.770,0:20:47.429 +pode resolver o que é chamado de problema de vinculação de recursos + +0:20:48.130,0:20:50.130 +Assim, neurocientistas visuais e + +0:20:50.320,0:20:56.190 +as pessoas de visão computacional tinham o problema --era uma espécie de quebra-cabeça-- Como é que + +0:20:57.489,0:21:01.289 +percebemos os objetos como objetos? Objetos são coleções de recursos + +0:21:01.290,0:21:04.229 +mas como ligamos todos os recursos de um objeto para formar esse objeto? + +0:21:06.460,0:21:09.870 +Existe algum tipo de maneira mágica de fazer isso? + +0:21:12.520,0:21:16.589 +E eles fizeram... psicólogos fizeram experimentos como... + +0:21:24.210,0:21:26.210 +desenhe isso e depois aquilo + +0:21:28.239,0:21:31.349 +e você percebe a barra como + +0:21:32.469,0:21:39.419 +uma única barra porque você está acostumado a barras sendo obstruídas por outros objetos + +0:21:39.550,0:21:41.550 +e então você apenas assume que é uma oclusão + +0:21:44.410,0:21:47.579 +E depois há experimentos que descobrem o quanto eu tenho que + +0:21:48.430,0:21:52.109 +mude as duas barras para me fazer percebê-las como duas barras separadas + +0:21:53.980,0:21:56.580 +Mas, na verdade, no minuto em que eles se alinham perfeitamente e se você... + +0:21:57.250,0:21:59.080 +se você fizer isto.. + +0:21:59.080,0:22:03.809 +talvez exatamente idêntico ao que você vê aqui, mas agora você os percebe como dois objetos diferentes + +0:22:06.489,0:22:12.929 +Então, como parece que estamos resolvendo o problema de vinculação de recursos? + +0:22:15.880,0:22:21.450 +E o que isso mostra é que você não precisa de nenhum mecanismo específico para isso. Simplesmente acontece + +0:22:22.210,0:22:25.919 +Se você tiver não linearidades suficientes e treinar com dados suficientes + +0:22:26.440,0:22:33.359 +então, como efeito colateral, você obtém um sistema que resolve o problema de vinculação de recursos sem nenhum mecanismo específico para isso + +0:22:37.510,0:22:40.260 +Então aqui você tem duas formas e você move uma única + +0:22:43.060,0:22:50.519 +curso e vai de um seis e um, para um três, para um cinco e um, para um sete e um três + +0:22:53.140,0:22:55.140 +etc. + +0:23:00.020,0:23:07.480 +Certo, boa pergunta. Então a pergunta é: como você distingue entre as duas situações? Temos dois cincos um ao lado do outro e + +0:23:08.270,0:23:14.890 +o fato de você ter um único cinco sendo detectado por dois quadros diferentes, certo? Dois enquadramentos diferentes desses cinco + +0:23:15.470,0:23:17.470 +Bem, há isso explícito + +0:23:17.660,0:23:20.050 +treinando para que quando você tiver dois personagens que + +0:23:20.690,0:23:25.029 +estão se tocando e nenhum deles está realmente centralizado, você treina o sistema para dizer "nenhuma das opções acima", certo? + +0:23:25.030,0:23:29.079 +Então sempre vai ter cinco cinco em branco + +0:23:30.020,0:23:35.800 +Sempre vai ter um em branco, e os dois podem ser muito próximos. Será que você vai te dizer a diferença + +0:23:39.170,0:23:41.289 +Ok, então para que servem os convnets? + +0:24:04.970,0:24:07.599 +Então o que você tem que olhar é isso + +0:24:11.510,0:24:13.510 +Cada camada aqui é uma convolução + +0:24:13.610,0:24:15.020 +OK? + +0:24:15.020,0:24:21.070 +Incluindo a última camada, então parece uma conexão completa porque cada unidade na segunda camada vai para a saída + +0:24:21.070,0:24:24.460 +Mas, na verdade, é uma convolução, só acontece de ser aplicada a um único local + +0:24:24.950,0:24:31.300 +Então agora imagine que essa camada no topo aqui agora é maior, ok? Que está representado aqui + +0:24:32.840,0:24:34.130 +OK? + +0:24:34.130,0:24:37.779 +Agora o tamanho do kernel é o tamanho da imagem que você tinha aqui anteriormente + +0:24:37.820,0:24:43.360 +Mas agora é uma convolução que tem vários locais, certo? E então o que você obtém são várias saídas + +0:24:46.430,0:24:55.100 +Isso mesmo, isso mesmo. Cada um deles corresponde a uma classificação em uma janela de entrada de tamanho 32 por 32 no exemplo que mostrei + +0:24:55.100,0:25:02.710 +E essas janelas são deslocadas em 4 pixels. A razão é que a arquitetura de rede que mostrei + +0:25:04.280,0:25:11.739 +aqui tem uma convolução com passo um, então juntando com passo dois, convolução com passo um, juntando com passo dois + +0:25:13.949,0:25:17.178 +E assim o passo geral é quatro, certo? + +0:25:18.719,0:25:22.788 +E assim, para obter uma nova saída, você precisa deslocar a janela de entrada em quatro + +0:25:24.210,0:25:29.509 +para obter um desses por causa das duas camadas de pool com ... + +0:25:31.170,0:25:35.480 +Talvez eu devesse ser um pouco mais explícito sobre isso. Deixe-me desenhar uma imagem, isso seria mais claro + +0:25:39.929,0:25:43.848 +Então você tem uma entrada + +0:25:49.110,0:25:53.749 +assim... uma convolução, digamos uma convolução de tamanho três + +0:25:57.420,0:25:59.420 +OK? Sim com passo um + +0:26:01.289,0:26:04.518 +Ok, eu não vou desenhar todos eles, então você tem + +0:26:05.460,0:26:11.389 +agrupando com subamostragem de tamanho dois, então você agrupa mais de 2 e subamostra, o passo é 2, então você muda por dois + +0:26:12.389,0:26:14.389 +Sem sobreposição + +0:26:18.550,0:26:25.060 +Ok, então aqui a entrada é deste tamanho -- um dois, três, quatro, cinco, seis, sete, oito + +0:26:26.150,0:26:29.049 +porque a convolução é de tamanho três, você obtém + +0:26:29.840,0:26:31.840 +uma saída aqui de tamanho seis e + +0:26:32.030,0:26:39.010 +então quando você faz o agrupamento com subamostragem com passo dois, você obtém três saídas porque isso divide a saída por dois, ok? + +0:26:39.880,0:26:41.880 +Deixe-me adicionar outro + +0:26:43.130,0:26:45.130 +Na verdade dois + +0:26:46.790,0:26:48.790 +Ok, então agora a saída é dez + +0:26:50.030,0:26:51.680 +Esse cara tem oito + +0:26:51.680,0:26:53.680 +Esse cara tem quatro + +0:26:54.260,0:26:56.409 +Eu posso fazer convoluções agora também + +0:26:57.650,0:26:59.650 +Digamos três + +0:27:01.400,0:27:03.400 +só tenho duas saídas + +0:27:04.490,0:27:06.490 +OK? Ops! + +0:27:07.040,0:27:10.820 +Hmm não tenho certeza porque não... desenha + +0:27:10.820,0:27:13.270 +Não quer mais desenhar, isso é interessante + +0:27:17.060,0:27:19.060 +Ah! + +0:27:24.110,0:27:26.380 +Ele não reage a cliques, isso é interessante + +0:27:34.460,0:27:39.609 +Ok, não tenho certeza do que está acontecendo! Oh "xournal" não está respondendo + +0:27:41.750,0:27:44.320 +Tudo bem, acho que caiu em mim + +0:27:46.550,0:27:48.550 +Bem, isso é irritante + +0:27:53.150,0:27:55.150 +Sim, definitivamente caiu + +0:28:02.150,0:28:04.150 +E, claro, ele esqueceu, então... + +0:28:09.860,0:28:12.760 +Ok, então temos dez, então oito + +0:28:15.230,0:28:20.470 +por causa da convolução com três, então temos o agrupamento + +0:28:22.520,0:28:24.520 +tamanho dois com + +0:28:26.120,0:28:28.120 +passo dois, então temos quatro + +0:28:30.350,0:28:36.970 +Então temos convolução com três, então temos dois, ok? E então talvez juntando novamente + +0:28:38.450,0:28:42.700 +de tamanho dois e subamostrando dois, obtemos um. OK, então... + +0:28:44.450,0:28:46.869 +dez entradas, oito + +0:28:49.370,0:28:53.079 +quatro, dois e... + +0:28:58.010,0:29:03.339 +então um para o pooling. Esta é a convolução três, você está certo + +0:29:06.500,0:29:08.500 +Isso é dois + +0:29:09.140,0:29:11.140 +E esses são três + +0:29:12.080,0:29:14.080 +etc. Certo. Agora, vamos supor + +0:29:14.540,0:29:17.860 +Eu adiciono algumas unidades aqui + +0:29:18.110,0:29:21.010 +OK? Então isso vai adicionar, digamos + +0:29:21.890,0:29:24.160 +quatro unidades aqui, duas unidades aqui + +0:29:27.620,0:29:29.620 +Então... + +0:29:41.190,0:29:42.840 +Sim, este é + +0:29:42.840,0:29:46.279 +assim e assim, então eu tenho quatro e + +0:29:47.010,0:29:48.960 +tenho outro aqui + +0:29:48.960,0:29:52.460 +OK? Então agora eu tenho apenas uma saída e adicionando quatro + +0:29:53.640,0:29:55.640 +quatro entradas aqui + +0:29:55.830,0:29:58.249 +que não é 14. Eu tenho duas saídas + +0:29:59.790,0:30:02.090 +Por que quatro? Porque eu tenho 2 + +0:30:02.970,0:30:04.830 +passo de 2 + +0:30:04.830,0:30:10.939 +OK? Portanto, a proporção geral de subamostragem da entrada para a saída é 4, é 2 vezes 2 + +0:30:13.140,0:30:17.540 +Agora isso é 12, e isso é 6, e isso é 4 + +0:30:20.010,0:30:22.010 +Então isso é um... + +0:30:22.620,0:30:24.620 +demonstração do fato de que + +0:30:24.900,0:30:26.900 +você pode aumentar o tamanho da entrada + +0:30:26.900,0:30:32.330 +aumentará o tamanho de cada camada, e se você tiver uma camada com tamanho 1 e for uma camada convolucional + +0:30:32.330,0:30:34.330 +seu tamanho vai aumentar + +0:30:42.870,0:30:44.870 +sim + +0:30:47.250,0:30:52.760 +Alterar o tamanho de uma camada, tipo, verticalmente, horizontalmente? Sim, então vai ter... + +0:30:54.390,0:30:57.950 +Então, primeiro você tem que treinar para isso, se você quer que o sistema tenha tanta invariância de tamanho + +0:30:58.230,0:31:03.860 +você tem que treiná-lo com personagens de vários tamanhos. Você pode fazer isso com aumento de dados se seus personagens forem normalizados + +0:31:04.740,0:31:06.740 +Essa é a primeira coisa. Segunda coisa é... + +0:31:08.850,0:31:16.579 +redes convolucionais empiricamente simples são apenas invariantes ao tamanho dentro de um fator de... fator bastante pequeno, como você pode aumentar o tamanho por + +0:31:17.610,0:31:23.599 +talvez 40 por cento ou algo assim. Quero dizer, mude o tamanho cerca de 40% mais/menos 20%, algo assim, certo? + +0:31:26.250,0:31:28.250 +Além disso... + +0:31:28.770,0:31:33.830 +você pode ter mais problemas para obter invariância, mas as pessoas treinaram com entrada ... + +0:31:33.980,0:31:38.390 +Quero dizer objetos de tamanhos que variam muito. Então, a maneira de lidar com isso é + +0:31:39.750,0:31:46.430 +se você quiser lidar com tamanho variável, é que se você tem uma imagem e não sabe o tamanho dos objetos + +0:31:46.950,0:31:50.539 +que estão nesta imagem, você aplica sua rede convolucional a essa imagem e + +0:31:51.180,0:31:53.979 +então você pega a mesma imagem, reduz por um fator de dois + +0:31:54.440,0:31:58.179 +apenas dimensione a imagem por um fator de dois, execute a mesma rede convolucional nessa nova imagem e + +0:31:59.119,0:32:02.949 +em seguida, reduza-o por um fator de dois novamente e execute a mesma rede convolucional novamente nessa imagem + +0:32:03.800,0:32:08.110 +OK? Assim, a primeira rede convolucional será capaz de detectar pequenos objetos dentro da imagem + +0:32:08.630,0:32:11.859 +Então, digamos que sua rede foi treinada para detectar objetos de tamanho... + +0:32:11.860,0:32:16.179 +Eu não sei, 20 pixels, como rostos por exemplo, certo? São 20 pixels + +0:32:16.789,0:32:20.739 +Ele detectará rostos com aproximadamente 20 pixels nesta imagem e + +0:32:21.320,0:32:24.309 +então, quando você subamostra por um fator de 2 e aplica a mesma rede + +0:32:24.309,0:32:31.209 +ele detectará rostos com 20 pixels na nova imagem, o que significa que havia 40 pixels na imagem original + +0:32:32.179,0:32:37.899 +OK? Que a primeira rede não verá porque o rosto seria maior que sua janela de entrada + +0:32:39.170,0:32:41.529 +E então a próxima rede detectará + +0:32:42.139,0:32:44.409 +rostos de 80 pixels, etc., certo? + +0:32:44.659,0:32:49.089 +Então, combinando as pontuações de todos esses, e fazendo algo chamado supressão não máxima + +0:32:49.090,0:32:51.090 +podemos realmente fazer a detecção e + +0:32:51.230,0:32:57.939 +localização de objetos. As pessoas usam técnicas consideravelmente mais sofisticadas para detecção agora e para localização, sobre as quais falaremos na próxima semana + +0:32:58.429,0:33:00.429 +Mas essa é a ideia básica + +0:33:00.920,0:33:02.920 +Então deixe-me concluir + +0:33:03.019,0:33:09.429 +Para que servem os convnets? Eles são bons para sinais que chegam até você na forma de uma matriz multidimensional + +0:33:10.190,0:33:12.190 +Mas essa matriz multidimensional tem + +0:33:13.190,0:33:17.500 +ter pelo menos duas características. O primeiro é + +0:33:18.469,0:33:23.828 +há fortes correlações locais entre os valores. Então, se você tirar uma imagem + +0:33:24.949,0:33:32.949 +imagem aleatória, pegue dois pixels dentro desta imagem, dois pixels que estão próximos. Esses dois pixels provavelmente terão cores muito semelhantes + +0:33:33.530,0:33:38.199 +Tire uma foto dessa aula, por exemplo, dois pixels na parede têm basicamente a mesma cor + +0:33:39.469,0:33:42.069 +OK? Parece que há uma tonelada de objetos aqui, mas + +0:33:43.280,0:33:49.509 +--animar objetos-- mas na verdade principalmente, estatisticamente, os pixels vizinhos são essencialmente da mesma cor + +0:33:52.699,0:34:00.129 +À medida que você move a distância de dois pixels de distância e calcula as estatísticas de quão semelhantes os pixels são em função da distância + +0:34:00.650,0:34:02.650 +são cada vez menos parecidos + +0:34:03.079,0:34:05.079 +Então, o que isso significa? Porque + +0:34:06.350,0:34:09.430 +pixels próximos provavelmente terão cores semelhantes + +0:34:09.560,0:34:14.499 +isso significa que quando você pega um pedaço de pixels, digamos cinco por cinco, ou oito por oito ou algo assim + +0:34:16.040,0:34:18.040 +O tipo de patch que você vai observar + +0:34:18.920,0:34:21.159 +é muito provável que seja uma espécie de variação suave + +0:34:21.830,0:34:23.830 +cor ou talvez com uma borda + +0:34:24.770,0:34:32.080 +Mas entre todas as combinações possíveis de 25 pixels, as que você realmente observa em imagens naturais é um pequeno subconjunto + +0:34:34.130,0:34:38.380 +O que isso significa é que é vantajoso representar o conteúdo desse patch + +0:34:39.440,0:34:46.509 +por um vetor com talvez menos de 25 valores que representam o conteúdo desse patch. Existe uma borda, é uniforme? + +0:34:46.690,0:34:48.520 +Que cor é essa? Você sabe coisas assim, certo? + +0:34:48.520,0:34:52.660 +E é basicamente isso que as convoluções na primeira camada de uma rede convolucional estão fazendo + +0:34:53.900,0:34:58.809 +OK. Portanto, se você tiver correlações locais, há uma vantagem em detectar recursos locais + +0:34:59.090,0:35:01.659 +Isso é o que observamos no cérebro. Isso é o que as redes convolucionais estão fazendo + +0:35:03.140,0:35:08.140 +Essa ideia de localidade. Se você alimentar uma rede convolucional com pixels permutados + +0:35:09.020,0:35:15.070 +não será capaz de fazer um bom trabalho em reconhecer suas imagens, mesmo que a permutação seja fixa + +0:35:17.030,0:35:19.960 +Certo? Uma rede totalmente conectada não se importa + +0:35:21.410,0:35:23.410 +sobre permutações + +0:35:25.700,0:35:28.240 +Então a segunda característica é que + +0:35:30.050,0:35:34.869 +recursos importantes podem aparecer em qualquer lugar da imagem. Então é isso que justifica pesos compartilhados + +0:35:35.630,0:35:38.499 +OK? A correlação local justifica conexões locais + +0:35:39.560,0:35:46.570 +O fato de que os recursos podem aparecer em qualquer lugar, que as estatísticas das imagens ou o sinal são uniformes + +0:35:47.810,0:35:52.030 +significa que você precisa ter detectores de recursos repetidos para cada local + +0:35:52.850,0:35:54.850 +E é aí que pesos compartilhados + +0:35:55.880,0:35:57.880 +entre no jogo + +0:36:01.990,0:36:06.059 +Isso justifica o pooling porque o pooling é se você quiser que a invariância + +0:36:06.760,0:36:11.400 +variações na localização dessas feições características. E se os objetos que você está tentando reconhecer + +0:36:12.340,0:36:16.619 +não mude sua natureza meio que distorcida, então você quer agrupar + +0:36:21.160,0:36:24.360 +Então, as pessoas usaram convnets para coisas de câncer, vídeo de imagem + +0:36:25.660,0:36:31.019 +texto, fala. Então a fala é realmente bonita... as redes de reconhecimento de fala são muito usadas + +0:36:32.260,0:36:34.380 +Previsão de séries temporais, você sabe coisas assim + +0:36:36.220,0:36:42.030 +E você conhece a análise de imagens biomédicas, então se você quiser analisar uma ressonância magnética, por exemplo + +0:36:42.030,0:36:44.030 +A ressonância magnética ou tomografia computadorizada é uma imagem 3d + +0:36:44.950,0:36:49.170 +Como humanos, não podemos porque não temos uma boa tecnologia de visualização. Nós não podemos realmente + +0:36:49.960,0:36:54.960 +apreender ou compreender um volume 3D, uma imagem tridimensional + +0:36:55.090,0:36:58.709 +Mas um convnet está bem, alimente-o com uma imagem 3d e ele lidará com isso + +0:36:59.530,0:37:02.729 +Isso é uma grande vantagem porque você não precisa passar por fatias para descobrir + +0:37:04.000,0:37:06.030 +o objeto na imagem + +0:37:10.390,0:37:15.300 +E a última coisa aqui embaixo, não sei se vocês sabem onde estão as imagens hiperespectrais + +0:37:15.300,0:37:19.139 +Então, a imagem hiperespectral é uma imagem onde... a maioria das imagens de cores naturais + +0:37:19.140,0:37:22.619 +Quero dizer, imagens que você coleta com uma câmera normal, você obtém três componentes de cores + +0:37:23.470,0:37:25.390 +RGB + +0:37:25.390,0:37:28.019 +Mas podemos construir câmeras com muito mais + +0:37:28.660,0:37:30.660 +bandas espectrais do que isso e + +0:37:31.510,0:37:34.709 +esse é particularmente o caso de imagens de satélite, onde alguns + +0:37:36.160,0:37:40.920 +câmeras têm muitas bandas espectrais indo do infravermelho ao ultravioleta e + +0:37:41.890,0:37:44.610 +que fornece muitas informações sobre o que você vê em cada pixel + +0:37:45.760,0:37:47.040 +Alguns pequenos animais + +0:37:47.040,0:37:54.930 +que têm cérebros pequenos acham mais fácil processar imagens hiperespectrais de baixa resolução do que imagens de alta resolução com apenas três cores + +0:37:55.750,0:38:00.450 +Por exemplo, há um tipo específico de camarão, certo? Eles têm aqueles lindos + +0:38:01.630,0:38:07.499 +olhos e eles têm tipo 17 bandas espectrais ou algo assim, mas resolução super baixa e eles têm um cérebro minúsculo para processá-lo + +0:38:09.770,0:38:12.850 +Ok, isso é tudo por hoje. Vê você! \ No newline at end of file diff --git a/docs/pt/week03/practicum03.sbv b/docs/pt/week03/practicum03.sbv new file mode 100644 index 000000000..e9d44d1a9 --- /dev/null +++ b/docs/pt/week03/practicum03.sbv @@ -0,0 +1,1751 @@ +0:00:00.020,0:00:07.840 +Então, redes neurais convolucionais, acho que hoje eu me funda, sabe, eu posto coisas legais no Twitter + +0:00:09.060,0:00:11.060 +Me siga. Estou brincando + +0:00:11.290,0:00:16.649 +Tudo bem. Então, novamente, sempre que você não tem ideia do que está acontecendo. Apenas me pare de fazer perguntas + +0:00:16.900,0:00:23.070 +Vamos tornar essas aulas interativas para que eu possa tentar agradá-lo e fornecer as informações necessárias + +0:00:23.980,0:00:25.980 +Para você entender o que está acontecendo? + +0:00:26.349,0:00:27.970 +tudo bem, então + +0:00:27.970,0:00:31.379 +Redes neurais convolucionais. Quão legal é essa coisa? Muito legal + +0:00:32.439,0:00:38.699 +principalmente porque antes de ter redes convolucionais não podíamos fazer muito e vamos descobrir por que agora + +0:00:39.850,0:00:43.800 +como por que e como essas redes são tão poderosas e + +0:00:44.379,0:00:48.329 +Eles vão estar basicamente fazendo eles estão fazendo como um grande + +0:00:48.879,0:00:52.859 +Pedaço de como as redes inteiras são usadas nos dias de hoje + +0:00:53.980,0:00:55.300 +assim + +0:00:55.300,0:01:02.369 +Mais especificamente, vamos nos acostumar a repetir várias vezes essas três palavras, que são as palavras-chave para entender + +0:01:02.920,0:01:05.610 +Convoluções, mas vamos descobrir isso em breve + +0:01:06.159,0:01:09.059 +então vamos começar e descobrir como + +0:01:09.580,0:01:11.470 +esses + +0:01:11.470,0:01:13.470 +sinaliza essas imagens e essas + +0:01:13.990,0:01:17.729 +itens diferentes parecem assim sempre que falamos sobre + +0:01:18.670,0:01:21.000 +sinais que podemos pensar sobre eles como + +0:01:21.580,0:01:23.200 +vetores por exemplo + +0:01:23.200,0:01:30.600 +Temos aí um sinal que está representando um sinal de áudio monofônico, dado que é apenas + +0:01:31.180,0:01:38.339 +Temos apenas a dimensão temporal entrando como o sinal acontece em uma dimensão, que é a dimensão temporal + +0:01:38.560,0:01:46.079 +Isso é chamado de sinal 1d e pode ser representado por um vetor singular como é mostrado lá em cima + +0:01:46.750,0:01:48.619 +cada + +0:01:48.619,0:01:52.389 +O valor desse vetor representa a amplitude da forma de onda + +0:01:53.479,0:01:56.589 +por exemplo, se você tiver apenas um sinal, você vai ouvir como + +0:01:57.830,0:01:59.830 +Como alguns soam assim + +0:02:00.560,0:02:05.860 +Se você tem um tipo diferente de você sabe, não é apenas um sinal, um sinal que você vai ouvir + +0:02:06.500,0:02:08.500 +diferentes tipos de madeiras ou + +0:02:09.200,0:02:11.200 +tipo diferente de + +0:02:11.360,0:02:13.190 +tipo diferente de + +0:02:13.190,0:02:15.190 +sabor do som + +0:02:15.440,0:02:18.190 +Além disso, você está familiarizado. Como o som funciona, certo? assim + +0:02:18.709,0:02:21.518 +Agora estou apenas jogando ar pela minha traqueia + +0:02:22.010,0:02:26.830 +onde existem como algumas membranas que estão fazendo o ar vibrar essas + +0:02:26.930,0:02:33.640 +A vibração se propaga pelo ar, atingindo seus ouvidos e o canal auditivo que você tem dentro de alguns pequenos + +0:02:35.060,0:02:38.410 +você provavelmente tem a cóclea certa e, em seguida, deu cerca de + +0:02:38.989,0:02:45.159 +Quanto o som se propaga pela cóclea, você detectará o tom e, em seguida, adicionará um tom diferente + +0:02:45.830,0:02:49.119 +informações que você pode e também gosta de diferentes tipos de + +0:02:50.090,0:02:53.350 +sim, acho que informações de fala você vai descobrir qual é o + +0:02:53.930,0:02:59.170 +Som que eu estava fazendo aqui e então você reconstrói isso usando seu modelo de linguagem que você tem em seu cérebro + +0:02:59.170,0:03:03.369 +Certo e a mesma coisa que Yun estava mencionando se você começar a falar outro idioma + +0:03:04.310,0:03:11.410 +então você não poderá analisar as informações porque está usando um modelo de fala como uma conversão entre + +0:03:12.019,0:03:17.709 +Vibrações e afins, você sabe sinalizar seu cérebro mais o modelo de linguagem para fazer sentido + +0:03:18.709,0:03:22.629 +De qualquer forma, isso era um sinal 1d. Digamos que estou ouvindo música, então + +0:03:23.570,0:03:25.570 +Que tipo de sinal eu faço? + +0:03:25.910,0:03:27.910 +tem lá + +0:03:28.280,0:03:34.449 +Então, se eu ouvir a música do usuário vai ser um olhar estereofônico, certo? Então significa que você vai ter quantos canais? + +0:03:35.420,0:03:37.420 +Dois canais, certo? + +0:03:37.519,0:03:38.570 +no entanto + +0:03:38.570,0:03:41.019 +Que tipo de sinal vai ser esse? + +0:03:41.150,0:03:46.420 +Ainda vai ser um este sinal, embora existam dois canais para que você possa pensar, você sabe + +0:03:46.640,0:03:54.459 +independentemente de quantos canais cantados, como se você tivesse Dolby Surround, você terá o que 5.1, então seis, acho que sim, esse é o + +0:03:55.050,0:03:56.410 +Você sabe + +0:03:56.410,0:03:58.390 +vetorial o + +0:03:58.390,0:04:02.790 +tamanho do sinal e então o tempo é a única variável que é + +0:04:03.820,0:04:07.170 +Como se mover para sempre. OK. Então esses são sinais 1d + +0:04:09.430,0:04:13.109 +Tudo bem, então vamos dar uma olhada, vamos ampliar um pouco para + +0:04:14.050,0:04:18.420 +Nós temos isso. Por exemplo, do lado esquerdo. Temos algo que se parece com um senoidal + +0:04:19.210,0:04:25.619 +funcionar aqui, no entanto, um pouco depois você terá novamente o mesmo tipo de + +0:04:27.280,0:04:29.640 +Função aparecendo novamente, então isso é chamado + +0:04:30.460,0:04:37.139 +Estacionaridade você verá repetidas vezes o mesmo tipo de padrão ao longo do tempo + +0:04:37.810,0:04:39.810 +Dimensão, ok + +0:04:40.090,0:04:47.369 +Então, a primeira propriedade deste sinal, que é o nosso sinal natural, porque acontece na natureza, será que dissemos + +0:04:49.330,0:04:51.330 +Estacionaridade, ok. Esse é o primeiro + +0:04:51.580,0:04:53.580 +Além disso o que você acha? + +0:04:54.130,0:04:56.130 +Quão provável é? + +0:04:56.140,0:05:00.989 +Se eu tiver um pico do lado esquerdo para ter um pico também muito próximo + +0:05:03.430,0:05:09.510 +Então, qual é a probabilidade de ter um pico lá em vez de ter um pico lá, dado que você teve um pico antes ou + +0:05:09.610,0:05:11.590 +se eu continuar + +0:05:11.590,0:05:18.119 +Qual é a probabilidade de você ter um pico, você sabe alguns segundos depois, pois tem um pico no lado esquerdo. assim + +0:05:19.960,0:05:24.329 +Deveria haver algum tipo de conhecimento comum de senso comum, talvez, que + +0:05:24.910,0:05:27.390 +Se vocês estão juntos e se estão + +0:05:28.000,0:05:33.360 +Perto do lado esquerdo, haverá uma probabilidade maior de que as coisas pareçam + +0:05:33.880,0:05:40.589 +Semelhante, por exemplo, você tem como um som específico terá um tipo muito específico de forma + +0:05:41.170,0:05:43.770 +Mas então se você for um pouco mais longe desse som + +0:05:44.050,0:05:50.010 +então não há mais relação sobre o que aconteceu aqui dado o que aconteceu antes e então se você + +0:05:50.410,0:05:55.170 +Calcule a correlação cruzada entre um sinal e ele mesmo, você sabe o que é uma correlação cruzada? + +0:05:57.070,0:06:02.670 +Sabe como se você não sabe ok quantas mãos para cima quem não sabe uma correlação cruzada + +0:06:04.360,0:06:07.680 +Tudo bem, então isso vai ser lição de casa para você + +0:06:07.680,0:06:14.489 +Se você pegar um sinal apenas um sinal de áudio, eles realizam a convolução desse sinal consigo mesmo + +0:06:14.650,0:06:15.330 +OK + +0:06:15.330,0:06:19.680 +e então a convolução vai ser você tem seu próprio sinal você pega a coisa você vira e então você + +0:06:20.170,0:06:22.170 +passá-lo e então você multiplica + +0:06:22.390,0:06:25.019 +Sempre que você vai tê-los sobrepostos no mesmo + +0:06:25.780,0:06:27.780 +Como quando há zero + +0:06:28.450,0:06:33.749 +Desalinhamento você vai ter como um pico. E então, quando você começar a se mover, terá basicamente dois + +0:06:34.360,0:06:36.930 +lados que representa o fato de que + +0:06:37.990,0:06:44.850 +As coisas têm muitas coisas em comum basicamente realizando um produto escalar certo? Então, coisas que têm muito em comum quando são + +0:06:45.370,0:06:47.970 +Muito perto de um local específico + +0:06:47.970,0:06:55.919 +Se você for mais longe, as coisas começam, você sabe fazer a média. Então aqui a segunda propriedade deste sinal natural é a localidade + +0:06:56.500,0:07:04.470 +A informação está contida em uma porção específica e partes do domínio temporal neste caso. OK. Então, antes que tivéssemos + +0:07:06.940,0:07:08.940 +Estacionaridade agora temos + +0:07:09.640,0:07:11.640 +Localidade tudo bem não + +0:07:12.160,0:07:17.999 +Abençoe. Tudo bem. Então que tal esse certo? Isso não tem nada a ver com o que aconteceu lá + +0:07:20.110,0:07:24.960 +Ok, então vamos olhar para o gatinho simpático que tipo de + +0:07:25.780,0:07:27.070 +dimensões + +0:07:27.070,0:07:31.200 +Que tipo de sim que dimensão tem esse sinal? Qual foi o seu palpite? + +0:07:32.770,0:07:34.829 +É um sinal bidimensional por que isso + +0:07:39.690,0:07:45.469 +Ok, também temos uma opção de sinal tridimensional aqui, então alguém disse duas dimensões alguém disse três dimensões + +0:07:47.310,0:07:51.739 +É bidimensional, por que é esse barulho lamentável? Por que é bidimensional + +0:07:54.030,0:07:56.030 +Porque a informação é + +0:07:58.050,0:08:00.050 +Desculpe a informação é + +0:08:00.419,0:08:01.740 +especialmente + +0:08:01.740,0:08:03.740 +retratado certo? Então as informações + +0:08:03.750,0:08:05.310 +é + +0:08:05.310,0:08:08.450 +Basicamente codificado na localização espacial desses pontos + +0:08:08.760,0:08:15.439 +Embora cada ponto seja um vetor por exemplo de três ou se for uma imagem hiperespectral. Pode ser vários aviões + +0:08:16.139,0:08:23.029 +No entanto, você ainda tem duas direções nas quais os pontos podem se mover, certo? A espessura não muda + +0:08:24.000,0:08:27.139 +transversalmente como nas espessuras de um determinado espaço + +0:08:27.139,0:08:33.408 +Certo, dada a espessura e não muda certo, então você pode ter quantos, você conhece os aviões que quiser + +0:08:33.409,0:08:35.409 +mas a informação é basicamente + +0:08:35.640,0:08:41.779 +É uma informação espacial espalhada pelo plano. Então, esses são dados bidimensionais que você também pode + +0:08:50.290,0:08:53.940 +Ok, eu vejo seu ponto como uma imagem ampla ou um + +0:08:54.910,0:08:56.350 +imagem em tons de cinza + +0:08:56.350,0:08:58.350 +com certeza é 2d + +0:08:58.870,0:09:04.169 +Sinal e também pode ser representado usando um tensor de duas dimensões + +0:09:04.870,0:09:07.739 +Uma imagem colorida tem planos RGB + +0:09:08.350,0:09:14.550 +mas a espessura é sempre três não muda e a informação ainda está espalhada pelo + +0:09:15.579,0:09:21.839 +Outras duas dimensões para que você possa alterar o tamanho de uma imagem colorida, mas não alterará a espessura de uma imagem colorida, certo? + +0:09:22.870,0:09:28.319 +Então estamos falando aqui. A dimensão do sinal é como fica a informação? + +0:09:29.470,0:09:31.680 +Basicamente espalhados pela informação temporal + +0:09:31.959,0:09:38.789 +Se você tem sinal mono mono Dolby Surround ou tem um estéreo ainda temos com o tempo, certo? + +0:09:38.790,0:09:41.670 +Então, as imagens unidimensionais são 2d + +0:09:42.250,0:09:44.759 +então vamos dar uma olhada no gatinho simpático e + +0:09:45.519,0:09:47.909 +Vamos focar no nariz, certo? Oh + +0:09:48.579,0:09:50.579 +Meu Deus, isso é um monstro. Não + +0:09:50.949,0:09:52.949 +OK. Bem grande + +0:09:53.649,0:09:55.948 +Criatura aqui, certo? OK, então + +0:09:56.740,0:10:03.690 +Nós observamos lá e há algum tipo de região escura perto do olho você pode observar esse tipo de ver um padrão + +0:10:04.329,0:10:09.809 +Aparece por lá, certo? Então, qual é essa propriedade dos sinais naturais? eu + +0:10:12.699,0:10:18.239 +Disse-lhe duas propriedades, esta é a estacionaridade. Por que essa estacionariedade? + +0:10:22.029,0:10:29.129 +Certo, então o mesmo padrão aparece repetidamente em toda a dimensionalidade, neste caso a dimensão é de duas dimensões. Desculpe + +0:10:30.220,0:10:36.600 +Além disso, qual é a probabilidade de que, dado que a cor da pupila seja preta? Qual é a probabilidade disso? + +0:10:37.149,0:10:42.448 +O pixel na seta ou como na ponta da seta também é preto + +0:10:42.449,0:10:47.879 +Eu diria que é bem provável que esteja certo porque é muito próximo. Que tal esse ponto? + +0:10:48.069,0:10:51.899 +Sim, meio menos provável certo se eu continuar clicando + +0:10:52.480,0:10:59.649 +Você sabe, é completamente brilhante. Não, não as outras fotos à direita, então você vai mais longe na dimensão espacial + +0:11:00.290,0:11:06.879 +Quanto menos provável você tiver, você saberá informações semelhantes. E assim se chama isso + +0:11:08.629,0:11:10.629 +Localidade que significa + +0:11:12.679,0:11:16.269 +Há uma maior probabilidade de as coisas terem se como + +0:11:16.549,0:11:22.509 +As informações são como contêineres em uma região específica à medida que você se move, as coisas ficam muito, muito mais + +0:11:24.649,0:11:26.649 +Você sabe independente + +0:11:27.199,0:11:32.529 +Tudo bem, então temos duas propriedades. A terceira propriedade será a seguinte. O que é isso? + +0:11:33.829,0:11:35.829 +Está com fome? + +0:11:37.579,0:11:41.769 +Então você pode ver aqui alguns donuts, sem donuts como você chamou + +0:11:42.649,0:11:44.230 +Bagels, certo? Tudo bem + +0:11:44.230,0:11:51.009 +Então, para você, aquele de vocês que tem óculos, tire os óculos e agora responda à minha pergunta + +0:11:53.179,0:11:55.179 +OK + +0:11:59.210,0:12:01.210 +Então a terceira propriedade + +0:12:02.210,0:12:07.059 +É certo de composicionalidade e assim composicionalidade significa que o + +0:12:07.880,0:12:10.119 +A palavra é realmente explicável, certo? + +0:12:11.060,0:12:13.060 +tudo bem, você gosta de + +0:12:15.830,0:12:20.199 +A coisa está bem, você tem que voltar para mim certo? Eu apenas tento manter sua vida + +0:12:26.180,0:12:28.100 +Olá + +0:12:28.100,0:12:33.520 +OK. Então, para quem não tem óculos, pergunte ao amigo que tem óculos e experimente-os. Okay agora + +0:12:34.430,0:12:36.430 +Não faça isso se não for bom + +0:12:37.010,0:12:43.659 +Estou brincando. Você pode apertar os olhos apenas rainha, não, não use óculos de outras pessoas. OK? + +0:12:44.990,0:12:46.990 +Pergunta. Sim + +0:12:50.900,0:12:52.130 +assim + +0:12:52.130,0:12:57.489 +Estacionaridade significa que você observa o mesmo tipo de padrão repetidamente em seus dados + +0:12:58.160,0:13:01.090 +Localidade significa que o padrão é apenas localizado + +0:13:01.820,0:13:08.109 +Então você tem algumas informações específicas aqui algumas informações aqui informações aqui conforme você se afasta deste ponto + +0:13:08.270,0:13:10.270 +esse outro valor vai ser + +0:13:10.760,0:13:11.780 +quase + +0:13:11.780,0:13:15.249 +Independente do valor deste ponto aqui. Então as coisas estão correlacionadas + +0:13:15.860,0:13:17.860 +Apenas dentro de um bairro, ok + +0:13:19.910,0:13:27.910 +Ok, todo mundo tem experimentado agora apertando os olhos e olhando para esta bela foto, ok. Então esta é a terceira parte que é composicionalidade + +0:13:28.730,0:13:32.289 +Aqui você pode dizer como você pode realmente ver algo + +0:13:33.080,0:13:35.080 +Se você borrar um pouco + +0:13:35.810,0:13:39.250 +porque novamente as coisas são feitas de pequenas peças e você pode realmente + +0:13:40.010,0:13:42.429 +Você sabe compor as coisas dessa maneira + +0:13:43.400,0:13:47.829 +de qualquer forma, então essas são as três propriedades principais dos sinais naturais, que + +0:13:48.650,0:13:50.650 +permita-nos + +0:13:51.260,0:13:55.960 +Pode ser explorado para fazer, você sabe, um projeto de nossa arquitetura, que é mais + +0:13:56.600,0:14:00.880 +Realmente propenso a extrair informações que tenham essas propriedades + +0:14:00.880,0:14:05.169 +Ok, então estamos falando agora sobre sinais que exibem essas propriedades + +0:14:07.730,0:14:11.500 +Finalmente tudo bem. Teve o último que eu não falei então + +0:14:12.890,0:14:18.159 +Tivemos o último aqui. Temos uma frase em inglês, certo John pegou a maçã + +0:14:18.779,0:14:22.818 +qualquer coisa e aqui novamente, você pode representar cada palavra como + +0:14:23.399,0:14:26.988 +Um vetor, por exemplo, cada um desses itens. Pode ser um + +0:14:27.869,0:14:30.469 +Vetor que tem 1 no correspondente + +0:14:31.110,0:14:35.329 +Correspondência para a posição de onde essa palavra está no dicionário, ok + +0:14:35.329,0:14:39.709 +então se você tem um dicionário de 10.000 palavras, você pode simplesmente checar o que for + +0:14:40.679,0:14:44.899 +A palavra neste dicionário você acabou de colocar a página mais o número + +0:14:45.629,0:14:50.599 +Como você acabou de descobrir que a posição da página no dicionário. Assim também a linguagem + +0:14:51.899,0:14:56.419 +Tem esse tipo de propriedades que as coisas que estão por perto têm, você sabe + +0:14:56.420,0:15:01.069 +Algum tipo de relacionamento, as coisas não são menos, a menos que você saiba + +0:15:01.470,0:15:05.149 +Padrões correlacionados e, em seguida, semelhantes acontecem repetidamente + +0:15:05.819,0:15:12.558 +Além disso, você pode usar as palavras que conhece para fazer frases para fazer redações completas e, finalmente, fazer suas redações para o + +0:15:12.839,0:15:16.008 +Sessões. Estou brincando. OK. Tudo bem, então + +0:15:17.429,0:15:19.789 +Já vimos este. Então eu vou muito rápido + +0:15:20.759,0:15:28.279 +acho que não deve haver nenhuma pergunta, porque também temos tudo escrito no site, certo para que você possa sempre verificar o + +0:15:28.860,0:15:30.919 +resumos da lição anterior no site + +0:15:32.040,0:15:39.349 +Camada tão totalmente conectada. Então, na verdade, talvez seja uma nova versão do diagrama. Este é o meu X,Y está na parte inferior + +0:15:42.089,0:15:49.698 +Características de baixo nível. Qual a cor dos decks? Cor de rosa. OK, bom. Tudo bem, então temos uma seta que representa minha + +0:15:51.299,0:15:54.439 +Sim, tudo bem, esse é o termo adequado, mas eu gosto de chamá-los + +0:15:55.410,0:16:02.299 +Rotações e depois há algum esmagamento certo? esmagamento significa a não linearidade, então eu tenho minha camada oculta, então eu tenho outra + +0:16:04.379,0:16:06.379 +Rotação e um final + +0:16:06.779,0:16:12.888 +Esmagamento. OK. Não é necessário. Talvez possa ser um linear, você sabe a transformação final como um linear + +0:16:14.520,0:16:18.059 +Seja qual for a função que eles são, se você fizer uma tarefa de regressão + +0:16:19.750,0:16:21.750 +Aí você tem as equações, certo + +0:16:22.060,0:16:24.060 +E esses caras podem ser qualquer um desses + +0:16:24.610,0:16:26.260 +funções não lineares ou + +0:16:26.260,0:16:33.239 +Mesmo uma função linear né se você fizer a regressão mais uma vez e assim você pode anotar essas camadas onde eu expando + +0:16:33.240,0:16:39.510 +Então esse cara aqui embaixo é na verdade um vetor e eu represento o vetor G com apenas um polo ali + +0:16:39.510,0:16:42.780 +Acabei de mostrar todos os cinco elementos de itens desse vetor + +0:16:43.030,0:16:45.239 +Então você tem o X na primeira camada? + +0:16:45.370,0:16:50.520 +Então você tem o primeiro segundo terceiro hit oculto e a última camada, então temos quantas camadas? + +0:16:53.590,0:16:55.240 +Cinco ok + +0:16:55.240,0:16:56.950 +E então você também pode chamá-los + +0:16:56.950,0:17:03.689 +camada de ativação 1 camada 2 3 4 o que for e então as matrizes são onde você armazena seu + +0:17:03.970,0:17:10.380 +Parâmetros você tem esses W's diferentes e então para pegar cada um desses valores você já viu as coisas, certo? + +0:17:10.380,0:17:17.280 +Então eu vou bem mais rápido você executa apenas o produto escalar. O que significa que você acabou de fazer aquela coisa + +0:17:17.860,0:17:23.400 +Você recebe todos esses pesos. Eu multiplico a entrada para cada um desses pesos e você continua assim + +0:17:24.490,0:17:28.920 +E então você armazena esses pesos nessas matrizes e assim por diante. Então, como você pode dizer + +0:17:30.700,0:17:37.019 +Tem muitas flechas né e independente do fato de eu ter passado muitas horas fazendo aquele desenho + +0:17:38.200,0:17:43.649 +Isso também é muito caro computacionalmente porque há tantos cálculos certos em cada seta + +0:17:44.350,0:17:46.350 +representa um peso que você tem que multiplicar + +0:17:46.960,0:17:49.110 +para like por sua própria entrada + +0:17:49.870,0:17:51.870 +assim + +0:17:52.090,0:17:53.890 +O que podemos fazer agora? + +0:17:53.890,0:17:55.150 +assim + +0:17:55.150,0:17:57.150 +visto que nossas informações + +0:17:57.700,0:18:04.679 +Tem localidade. Não os nossos dados têm esta localidade como propriedade. O que significa se eu tivesse algo aqui? + +0:18:05.290,0:18:07.290 +Eu me importo com o que está acontecendo aqui? + +0:18:09.460,0:18:12.540 +Então, alguns de vocês estão apenas apertando a mão e o resto + +0:18:13.000,0:18:17.219 +Você é meio que não sei não responde e eu tenho que te dar um ping + +0:18:18.140,0:18:18.900 +assim + +0:18:18.900,0:18:25.849 +Temos localidade, certo? Então as coisas estão apenas em regiões específicas. Você realmente se importa em olhar para longe + +0:18:27.030,0:18:28.670 +Não, tudo bem. Fantástico + +0:18:28.670,0:18:32.119 +Então, vamos simplesmente descartar algumas conexões, certo? + +0:18:32.130,0:18:38.660 +Então aqui vamos da camada L-1 para a camada L usando a primeira, você conhece cinco + +0:18:39.570,0:18:45.950 +Dez e quinze, certo? Além disso, eu tenho o último aqui da camada L para L+1 + +0:18:45.950,0:18:48.529 +Eu tenho mais três, então no total temos + +0:18:50.550,0:18:53.089 +Dezoito cálculos de pesos, certo + +0:18:53.760,0:18:55.760 +então, que tal nós + +0:18:56.370,0:19:01.280 +Largue as coisas que não nos importamos, certo? Então, digamos, para este neurônio, talvez + +0:19:01.830,0:19:04.850 +Por que temos que nos preocupar com aqueles caras lá no fundo, certo? + +0:19:05.160,0:19:08.389 +Então, por exemplo, eu posso usar esses três pesos, certo? + +0:19:08.390,0:19:12.770 +Eu apenas esqueço os outros dois e, novamente, eu apenas uso esses três pesos + +0:19:12.770,0:19:15.229 +Eu pulo o primeiro e o último e assim por diante + +0:19:16.170,0:19:23.570 +OK. Então agora temos apenas nove conexões agora apenas nove multiplicações e finalmente mais três + +0:19:24.360,0:19:28.010 +então, à medida que vamos do lado esquerdo para o lado direito, + +0:19:28.920,0:19:32.149 +Suba na hierarquia e teremos um número cada vez maior + +0:19:33.960,0:19:34.790 +Ver à direita + +0:19:34.790,0:19:40.879 +então, embora esses corpos verdes aqui e não vejam toda a entrada, você continua subindo o + +0:19:41.310,0:19:45.109 +Hierarquia você poderá ver toda a extensão da entrada, certo? + +0:19:46.590,0:19:48.590 +então, neste caso, vamos ser + +0:19:49.230,0:19:55.760 +Definindo a RF como campo receptivo. Então meu campo receptivo aqui desde o último + +0:19:56.400,0:20:03.769 +Neurônio para o neurônio intermediário é três. Então o que vai ser? Isso significa que o neurônio final vê três + +0:20:04.500,0:20:10.820 +Neurônios da camada anterior. Então, qual é o campo receptivo da camada oculta em relação à camada de entrada? + +0:20:14.970,0:20:21.199 +A resposta foi três. Sim, correto, mas qual é agora o campo séptico da camada de saída em relação à camada de entrada + +0:20:23.549,0:20:25.549 +Cinco certo. Isso é fantástico + +0:20:25.679,0:20:30.708 +Ok, doce. Então agora toda a arquitetura vê toda a entrada + +0:20:31.229,0:20:33.229 +enquanto cada subparte + +0:20:33.239,0:20:39.019 +Como as camadas intermediárias só vê pequenas regiões e isso é muito bom porque você vai poupar + +0:20:39.239,0:20:46.939 +Cálculos que são desnecessários porque em média não têm qualquer informação. E assim conseguimos acelerar + +0:20:47.669,0:20:50.059 +Os cálculos que você realmente pode calcular + +0:20:51.119,0:20:53.208 +coisas em um tempo razoável + +0:20:54.809,0:20:58.998 +Claro para que possamos falar sobre esparsidade apenas porque + +0:21:02.669,0:21:05.238 +Assumimos que nossos dados mostram + +0:21:06.329,0:21:08.249 +localidade, certo + +0:21:08.249,0:21:12.708 +Questione se meus dados não mostram a localidade. Posso usar esparsidade? + +0:21:16.139,0:21:19.279 +Não, tudo bem, fantástico, tudo bem. Tudo bem + +0:21:20.549,0:21:23.898 +mais coisas, então também dissemos que esses sinais naturais são + +0:21:24.209,0:21:28.399 +Estacionária e, portanto, dado que são estacionárias, as coisas aparecem repetidamente + +0:21:28.399,0:21:34.008 +Então talvez não tenhamos que aprender de novo as mesmas coisas de todo o tempo certo? assim + +0:21:34.679,0:21:37.668 +Neste caso, dissemos oh, deixamos de lado essas duas linhas, certo? + +0:21:38.729,0:21:41.179 +E então que tal usarmos? + +0:21:41.969,0:21:46.999 +A primeira conexão a oblíqua de você conhece indo para baixo + +0:21:47.549,0:21:52.158 +Faça-o amarelo. Então todos esses são amarelos, então estes são laranja + +0:21:52.859,0:21:57.139 +E então o último é vermelho, certo? Então, quantos pesos eu tenho aqui? + +0:21:59.639,0:22:01.639 +E eu tinha aqui + +0:22:03.089,0:22:05.089 +Nove à direita e antes que tivéssemos + +0:22:06.749,0:22:09.769 +15 certo, então caímos de 15 para 3 + +0:22:10.529,0:22:14.958 +Isso é como uma grande redução e como talvez agora não funcione + +0:22:14.969,0:22:16.759 +Então, temos que corrigir isso em um pouco + +0:22:16.759,0:22:22.368 +Mas de qualquer forma desta forma quando eu treino uma rede, eu só tive que treinar três pesos o vermelho + +0:22:22.840,0:22:25.980 +desculpe, o amarelo laranja e vermelho e + +0:22:26.889,0:22:30.959 +Na verdade, vai funcionar ainda melhor porque só precisa aprender + +0:22:31.749,0:22:37.079 +Você terá mais informações, terá mais dados para saber treinar esses pesos específicos + +0:22:41.320,0:22:48.299 +Então essas são essas três cores, o amarelo laranja e o vermelho vão ser chamados de meu kernel e então eu as armazenei + +0:22:48.850,0:22:50.850 +Em um vetor aqui + +0:22:53.200,0:22:58.679 +E então aqueles se você fala sobre você sabe cuidados convolucionais esses são simplesmente o peso desses + +0:22:59.200,0:22:59.909 +por aqui + +0:22:59.909,0:23:04.589 +Corrija os pesos que estamos usando usando esparsidade e, em seguida, usando o compartilhamento de parâmetros + +0:23:04.869,0:23:09.629 +Compartilhamento de parâmetros significa que você usa o mesmo parâmetro novamente em toda a arquitetura + +0:23:10.330,0:23:15.090 +Portanto, existem as seguintes propriedades interessantes de usar esses dois combinados + +0:23:15.490,0:23:20.699 +Assim, o compartilhamento de parâmetros nos dá uma convergência mais rápida porque você terá muito mais informações + +0:23:21.399,0:23:23.549 +Para usar para treinar esses pesos + +0:23:24.519,0:23:26.139 +Você tem um melhor + +0:23:26.139,0:23:32.008 +Generalização porque você não precisa aprender toda vez um tipo específico de coisa que aconteceu em uma região diferente + +0:23:32.009,0:23:34.079 +Você acabou de aprender alguma coisa. Isso faz sentido + +0:23:34.720,0:23:36.720 +Você sabe globalmente + +0:23:37.570,0:23:44.460 +Então nós também não estamos restritos ao tamanho da entrada isso é tão importante ray também Yann disse isso três vezes ontem + +0:23:45.700,0:23:48.029 +Por que não estamos restritos ao tamanho da entrada? + +0:23:54.039,0:24:00.449 +Porque podemos continuar mudando logo antes, neste outro caso, se você tiver mais neurônios, precisará aprender coisas novas + +0:24:00.450,0:24:06.210 +Certo, neste caso. Eu posso simplesmente adicionar mais neurônios e continuo usando meu peso certo que foi + +0:24:07.240,0:24:09.809 +Alguns dos principais pontos Yann, você sabe + +0:24:10.509,0:24:12.509 +destaque ontem + +0:24:12.639,0:24:14.939 +Além disso, temos a independência do kernel + +0:24:15.999,0:24:18.689 +Então, para um de vocês, eles estão interessados ​​em otimização + +0:24:19.659,0:24:21.009 +otimizando como computação + +0:24:21.009,0:24:22.299 +isso é tão legal porque + +0:24:22.299,0:24:29.189 +Este kernel e outro kernel são completamente independentes então você pode treiná-los você pode paralisar é fazer as coisas andarem mais rápido + +0:24:33.580,0:24:38.549 +Então, finalmente, temos também alguma propriedade de esparsidade de conexão e aqui temos uma + +0:24:39.070,0:24:41.700 +Quantidade reduzida de computação, o que também é muito bom + +0:24:42.009,0:24:48.659 +Então, todas essas propriedades nos permitiram treinar essa rede em muitos dados + +0:24:48.659,0:24:55.739 +você ainda precisa de muitos dados, mas sem ter localidade esparsa, portanto, sem ter esparsidade e + +0:24:56.409,0:25:01.859 +Compartilhamento de parâmetros, você não conseguiria concluir o treinamento desta rede em um período de tempo razoável + +0:25:03.639,0:25:11.039 +Então, vamos ver, por exemplo, agora como isso funciona quando você tem um sinal de áudio, que é quantos sinais dimensionais + +0:25:12.279,0:25:17.849 +1 sinal dimensional, certo? OK. Então, por exemplo, kernels para dados 1d + +0:25:18.490,0:25:24.119 +No lado direito. Você pode ver novamente. Meus meus neurônios posso estar usando meu + +0:25:24.909,0:25:30.359 +Diferente do primeiro scanner aqui. E então eu vou armazenar meu kernel lá nesse vetor + +0:25:31.330,0:25:36.059 +Por exemplo, posso ter um segundo kernel certo. Então agora temos dois kernels o + +0:25:36.700,0:25:39.749 +Azul roxo e rosa e amarelo, laranja e vermelho + +0:25:41.559,0:25:44.158 +Então vamos dizer que minha saída é r2 + +0:25:44.799,0:25:46.829 +Isso significa que cada um desses + +0:25:47.980,0:25:50.909 +Bolhas aqui. Cada um desses neurônios é realmente + +0:25:51.639,0:25:57.359 +Um e dois saem do tabuleiro, certo? Então, cada um deles tem uma espessura de dois + +0:25:58.929,0:26:02.819 +E digamos que o outro cara aqui está tendo uma espessura de sete, certo + +0:26:02.990,0:26:07.010 +Eles estão saindo da tela e são, você sabe, sete euros dessa maneira + +0:26:08.070,0:26:13.640 +então, neste caso, meu kernel terá tamanho 2 * 7 * 3 + +0:26:13.860,0:26:17.719 +Então 2 significa que eu tenho dois kernels que vão de 7 + +0:26:18.240,0:26:20.070 +para me dar + +0:26:20.070,0:26:22.070 +3 + +0:26:22.950,0:26:24.950 +Saídas + +0:26:28.470,0:26:32.959 +Segure meu mal. Então o 2 significa que você tem ℝ² aqui + +0:26:33.659,0:26:37.069 +Porque você tem dois cantos. Então o primeiro kernel lhe dará o primeiro + +0:26:37.679,0:26:41.298 +A primeira coluna aqui e o segundo kernel vão te dar a segunda coluna + +0:26:42.179,0:26:44.869 +Então tem que inicializar 7 + +0:26:45.210,0:26:50.630 +Porque precisa combinar com toda a espessura da camada anterior e aí tem 3 porque são três + +0:26:50.789,0:26:56.778 +Conexões certo? Então, talvez eu sinta falta de me confundir antes, faz sentido o dimensionamento? + +0:26:58.049,0:26:59.820 +assim dado que o nosso + +0:26:59.820,0:27:03.710 +273 2 significa que você tinha 2 kernels e, portanto, você tem dois + +0:27:04.080,0:27:08.000 +Itens aqui como um a um saindo para cada uma dessas colunas + +0:27:08.640,0:27:15.919 +Tem sete porque cada um deles tem uma espessura de 7 e finalmente 3 significa que existem 3 conexões conectando à camada anterior + +0:27:17.429,0:27:22.819 +Certo, então os dados 1d usam kernels 3d ok + +0:27:23.460,0:27:30.049 +então se eu chamar isso de minha coleção de kernel, certo, então se eles forem armazenados em um tensor + +0:27:30.049,0:27:32.898 +Este tensor será um tensor tridimensional + +0:27:33.690,0:27:34.919 +assim + +0:27:34.919,0:27:37.939 +Pergunta para você, se eu vou brincar agora com imagens + +0:27:38.580,0:27:40.580 +Qual é o tamanho de? + +0:27:40.679,0:27:43.999 +Você conhece o pacote completo de kernels para uma imagem + +0:27:45.809,0:27:47.809 +Rede convolucional + +0:27:49.590,0:27:56.209 +Quatro certo. Então, teremos o número de kernels, então será o número da espessura + +0:27:56.730,0:28:00.589 +E então você terá conexões em altura e conexões em largura + +0:28:01.799,0:28:03.179 +OK + +0:28:03.179,0:28:09.798 +Então, se você for verificar os kernels convolucionais atuais mais tarde em seu notebook, na verdade, você deve verificar isso + +0:28:09.929,0:28:12.138 +Você deve encontrar o mesmo tipo de dimensões + +0:28:14.159,0:28:16.159 +Tudo bem, então + +0:28:18.059,0:28:20.478 +Perguntas até agora, isso é tão claro?. Sim + +0:28:50.460,0:28:52.460 +Ok, boa pergunta então + +0:28:52.469,0:28:56.149 +trade-off sobre, você sabe o dimensionamento dessas circunvoluções + +0:28:56.700,0:28:59.119 +kernels convolucionais, certo está correto? Certo + +0:28:59.909,0:29:06.409 +Três por três, ele parece ser o mínimo que você pode obter se realmente se importa com informações espaciais + +0:29:07.499,0:29:13.098 +Como Yann apontou, você também pode usar uma convolução uma por uma. Oh, desculpe, venha um + +0:29:13.769,0:29:15.149 +como um + +0:29:15.149,0:29:20.718 +Convolução com que tem apenas um peso ou se usar como nas imagens tem uma convolução uma a uma + +0:29:21.179,0:29:23.179 +Esses são usados ​​para serem + +0:29:23.309,0:29:24.570 +tendo como um + +0:29:24.570,0:29:26.570 +camada final, que ainda + +0:29:26.909,0:29:30.528 +Ainda espacial pode ser aplicado a uma imagem de entrada maior + +0:29:31.649,0:29:36.138 +No momento, usamos apenas kernels que são três ou talvez cinco + +0:29:36.929,0:29:42.348 +é meio empírico, então não é como se não tivéssemos fórmulas mágicas, mas + +0:29:43.349,0:29:44.279 +temos sido + +0:29:44.279,0:29:50.329 +tentando arduamente nos últimos dez anos para descobrir qual é o melhor conjunto de hiperparâmetros e se você verificar + +0:29:50.969,0:29:55.879 +Para cada campo como para um processamento de fala processamento visual como processamento de imagem + +0:29:55.879,0:29:59.718 +Você vai descobrir qual é o compromisso certo para seus dados específicos? + +0:30:01.769,0:30:03.769 +Sim + +0:30:04.910,0:30:06.910 +Segundo + +0:30:07.970,0:30:12.279 +Ok, essa é uma boa pergunta por que números ímpares por que o kernel tem um número ímpar + +0:30:14.390,0:30:16.220 +De elementos + +0:30:16.220,0:30:20.049 +Então, se você realmente tiver um número ímpar de elementos, haveria um elemento central + +0:30:20.240,0:30:25.270 +Certo. Se você tiver um número par de elementos, saberemos que não haverá um valor central + +0:30:25.370,0:30:27.880 +Então, se você tiver novamente um número ímpar + +0:30:27.880,0:30:30.790 +Você sabe que a partir de um ponto específico você vai considerar + +0:30:31.220,0:30:36.789 +Número par de itens à esquerda e número par de itens à direita se for um tamanho par + +0:30:37.070,0:30:42.399 +Kernel que você realmente não sabe onde está o centro e o centro será a média de dois + +0:30:43.040,0:30:48.310 +Amostras vizinhas que realmente criam um efeito de filtro passa-baixa. Então mesmo + +0:30:49.220,0:30:51.910 +tamanhos de kernel geralmente não são + +0:30:52.580,0:30:56.080 +preferidos ou não usualmente usados ​​porque implicam algum tipo de + +0:30:57.290,0:30:59.889 +redução adicional da qualidade dos dados + +0:31:02.000,0:31:08.380 +Ok, então mais uma coisa que mencionamos também ontem, seu preenchimento é algo + +0:31:09.590,0:31:16.629 +que se isso afeta os resultados finais está piorando, mas é muito conveniente para + +0:31:17.570,0:31:25.450 +lado da programação, então, se tivermos o nosso, como você pode ver aqui, quando aplicarmos a convolução desta camada, você terminará com + +0:31:27.680,0:31:31.359 +Ok, quantos neurônios temos aqui + +0:31:32.720,0:31:34.720 +três e começamos de + +0:31:35.480,0:31:39.400 +cinco, então se usarmos um kernel convolucional de três + +0:31:40.490,0:31:42.490 +Perdemos quantos neurônios? + +0:31:43.310,0:31:50.469 +Dois, ok, um de cada lado. Se você estiver usando um kernel convolucional de tamanho cinco, quanto você perderá + +0:31:52.190,0:31:57.639 +Quatro à direita e, portanto, essa é a regra de preenchimento zero do usuário, você precisa adicionar um extra + +0:31:58.160,0:32:02.723 +Neurônio aqui um neurônio extra aqui. Então você vai fazer o tamanho do número do kernel, certo? + +0:32:02.723,0:32:05.800 +Três menos um dividido por dois e então você adiciona esse extra + +0:32:06.560,0:32:12.850 +Qualquer que seja o número de neurônios aqui, você os configurou para zero. Por que zerar? porque geralmente você zero significa + +0:32:13.470,0:32:18.720 +Suas entradas ou zerar a saída de cada camada usando algumas camadas de normalização + +0:32:19.900,0:32:21.820 +nesse caso + +0:32:21.820,0:32:25.770 +Sim, três vem do tamanho do kernel e então você tem isso + +0:32:26.740,0:32:28.630 +Alguma animação deve estar tocando + +0:32:28.630,0:32:31.289 +Sim, você tem um neurônio extra lá então + +0:32:31.289,0:32:37.289 +Eu tenho um neurônio extra lá de tal forma que finalmente você acaba com isso, você sabe, neurônios fantasmas lá + +0:32:37.330,0:32:41.309 +Mas agora você tem o mesmo número de entrada e o mesmo número de saída + +0:32:41.740,0:32:47.280 +E isso é tão conveniente porque se começamos com eu não sei 64 neurônios, você aplica uma convolução + +0:32:47.280,0:32:54.179 +Você ainda tem 64 neurônios e, portanto, você pode usar, digamos, o agrupamento máximo de dois, você terminará em 32 neurônios + +0:32:54.179,0:32:57.809 +Caso contrário você vai ter isso eu não sei se você considera um + +0:32:58.539,0:33:01.019 +Temos um número ímpar certo, então você não sabe o que fazer + +0:33:04.030,0:33:06.030 +depois de um tempo né? + +0:33:08.320,0:33:10.320 +OK, então + +0:33:10.720,0:33:12.720 +Sim, e você tem o mesmo tamanho + +0:33:13.539,0:33:20.158 +Tudo bem. Então, vamos ver quanto tempo você tem. Você tem um pouco de tempo. Então, vamos ver como usamos isso + +0:33:21.130,0:33:27.270 +Rede convolucional na prática. Então, isso é como a teoria por trás e dissemos que podemos usar convoluções + +0:33:28.000,0:33:33.839 +Portanto, este é um operador convolucional. Eu nem defini. O que é uma convolução. Acabamos de dizer que se nossos dados + +0:33:37.090,0:33:39.929 +localidade de estacionaridade e é na verdade + +0:33:42.130,0:33:45.689 +Composicional, então podemos explorar isso usando + +0:33:49.240,0:33:51.240 +Compartilhamento de peso + +0:33:51.940,0:33:56.730 +Esparsidade e então você sabe empilhando várias dessa camada. Você tem um tipo de hierarquia, certo? + +0:33:58.510,0:34:06.059 +Então, usando esse tipo de operação, isso é uma convolução, eu nem defini isso, não me importo agora, talvez na próxima aula + +0:34:07.570,0:34:11.999 +Então isso é como a teoria por trás agora, vamos ver um pouco de prática + +0:34:12.429,0:34:15.628 +Você conhece sugestões de como realmente usamos essas coisas na prática + +0:34:16.119,0:34:22.229 +Então, a próxima coisa que temos como padrão é uma rede convolucional espacial que está operando que tipo de dados + +0:34:22.840,0:34:24.840 +Se é espacial + +0:34:25.780,0:34:28.229 +É especial porque é minha rede né especial + +0:34:29.260,0:34:32.099 +Não apenas brincando tão especial como você conhece o espaço + +0:34:33.190,0:34:37.139 +Então, neste caso, temos várias camadas, é claro que as prendemos + +0:34:37.300,0:34:42.419 +Também falamos sobre por que é melhor ter várias camadas em vez de ter uma camada de gordura + +0:34:43.300,0:34:48.149 +Temos circunvoluções. É claro que temos não linearidades porque, caso contrário, + +0:34:55.270,0:34:56.560 +assim + +0:34:56.560,0:35:04.439 +ok, da próxima vez vamos ver como uma convolução pode ser implementada com matrizes, mas as convoluções são apenas operadores lineares com os quais muitos + +0:35:04.440,0:35:07.470 +zeros e como replicação do mesmo pelos pesos + +0:35:07.570,0:35:13.019 +mas caso contrário, se você não usar não linearidade, uma convolução de uma convolução + +0:35:13.020,0:35:16.679 +Vai ser uma convolução. Então temos que limpar as coisas + +0:35:17.680,0:35:19.510 +aquele + +0:35:19.510,0:35:25.469 +A gente tem que gostar de colocar barreiras né? para evitar o colapso de toda a rede. Tínhamos algum operador de pooling + +0:35:26.140,0:35:27.280 +que + +0:35:27.280,0:35:33.989 +Geoffrey diz que é você sabe, algo já ruim. Mas você sabe, você ainda está fazendo isso Hinton certo Geoffrey Hinton + +0:35:35.410,0:35:40.950 +Então, tivemos algo que, se você não usar, sua rede não estará treinando. Então é só usar + +0:35:41.560,0:35:44.339 +embora não saibamos exatamente por que funciona, mas + +0:35:45.099,0:35:48.659 +Acho que há uma pergunta na Piazza. vou colocar um link lá + +0:35:49.330,0:35:53.519 +Sobre esta normalização de lote. Além disso, Yann cobrirá todas as camadas de normalização + +0:35:54.910,0:36:01.889 +Finalmente, temos algo que também é bastante recente que é chamado de conexões de recebimento ou desvio + +0:36:01.990,0:36:03.990 +Quais são basicamente estes? + +0:36:04.240,0:36:05.859 +extra + +0:36:05.859,0:36:07.089 +conexões + +0:36:07.089,0:36:09.089 +Que me permitem + +0:36:09.250,0:36:10.320 +Obtenha a rede + +0:36:10.320,0:36:13.320 +Você sabe que a rede decidiu se deve enviar informações + +0:36:13.780,0:36:18.780 +Através desta linha ou realmente envie-a para frente se você empilhar tantas camadas uma após a outra + +0:36:18.910,0:36:24.330 +O sinal se perde um pouco depois de algum tempo se você adicionar essas conexões adicionais + +0:36:24.330,0:36:27.089 +Você sempre tem como um caminho para voltar + +0:36:27.710,0:36:31.189 +De baixo para cima e também ter gradientes descendo de cima para baixo + +0:36:31.440,0:36:38.599 +então isso é realmente muito importante, tanto a conexão do receptor quanto a normalização do lote são realmente muito úteis para fazer com que essa rede + +0:36:39.059,0:36:46.849 +Treine adequadamente se você não os usar, então será muito difícil fazer com que essas redes realmente funcionem para a parte do treinamento + +0:36:48.000,0:36:51.949 +Então como funciona temos aqui uma imagem, por exemplo + +0:36:53.010,0:36:55.939 +Onde a maior parte da informação é informação espacial? + +0:36:55.940,0:36:59.000 +Assim, a informação está espalhada pelas duas dimensões + +0:36:59.220,0:37:04.520 +Embora haja uma espessura e eu chamo a espessura como informação característica + +0:37:04.770,0:37:07.339 +O que significa que fornece uma informação? + +0:37:07.890,0:37:11.569 +Nesse ponto específico. Então, qual é a minha informação característica? + +0:37:12.180,0:37:15.740 +nesta imagem digamos que é uma imagem RGB + +0:37:16.680,0:37:18.680 +É uma imagem colorida certo? + +0:37:19.230,0:37:27.109 +Assim temos que a maior parte da informação está espalhada em uma informação espacial. Como se você me fizesse fazer caretas + +0:37:28.109,0:37:30.109 +mas então em cada ponto + +0:37:30.300,0:37:33.769 +Esta não é uma imagem em tons de cinza, é uma imagem colorida, certo? + +0:37:33.770,0:37:39.199 +Então cada ponto terá uma informação adicional que é minha você sabe + +0:37:39.990,0:37:42.439 +Informações características. O que é neste caso? + +0:37:44.640,0:37:46.910 +É um vetor de três valores que representam + +0:37:48.630,0:37:51.530 +RGB são as três letras do __, pois representam + +0:37:54.780,0:37:57.949 +Ok, no geral, como isso representa + +0:37:59.160,0:38:02.480 +Sim intensidade. Só você sabe, me diga em inglês sem estranho + +0:38:03.359,0:38:05.130 +coisas + +0:38:05.130,0:38:11.480 +A cor do pixel, certo? Então minhas informações específicas. Minha informação característica. Sim. Eu não sei o que você está dizendo + +0:38:11.480,0:38:18.500 +Desculpe, a informação característica neste caso é apenas uma cor certa então a cor é a única informação que é específica lá + +0:38:18.500,0:38:20.780 +Mas, caso contrário, a informação é espalhada por aí + +0:38:21.359,0:38:23.359 +Como se subíssemos escalar a hierarquia + +0:38:23.730,0:38:31.189 +Você pode ver agora algum vetor final que digamos que estamos fazendo a classificação neste caso. Então meu + +0:38:31.770,0:38:36.530 +Você sabe a altura e a largura ou a coisa vai ser uma por uma, então é apenas um vetor + +0:38:37.080,0:38:43.590 +E então digamos que você tenha o logit final específico, que é o mais alto, então representa a classe + +0:38:43.590,0:38:47.400 +Qual é mais provável de ser o correto se for bem treinado + +0:38:48.220,0:38:51.630 +no Midway, você tem algo que é, você conhece um trade-off entre + +0:38:52.330,0:38:59.130 +Informações espaciais e depois essas informações características. OK. Então, basicamente, é como uma conversão entre + +0:39:00.070,0:39:01.630 +informações espaciais + +0:39:01.630,0:39:03.749 +nesta informação característica + +0:39:04.360,0:39:07.049 +Você vê assim basicamente ir de uma coisa? + +0:39:07.660,0:39:08.740 +entrada + +0:39:08.740,0:39:13.920 +Dados para algo. É muito grosso, mas depois não tem mais informação informação espacial + +0:39:14.710,0:39:20.760 +e assim você pode ver aqui com minhas habilidades ninja PowerPoint como você pode conhecer um + +0:39:22.240,0:39:27.030 +Redução do espessante ___ como uma figura mais espessa em nossa apresentação + +0:39:27.070,0:39:30.840 +Considerando que você realmente perde o especial espacial + +0:39:32.440,0:39:39.870 +Ok, então isso foi mais um agrupamento, então o agrupamento é simplesmente novamente, por exemplo + +0:39:41.620,0:39:43.600 +Pode ser realizado desta forma + +0:39:43.600,0:39:48.660 +Então aí você tem um desenho à mão porque eu não queria que você tivesse tempo para fazer em látex? + +0:39:49.270,0:39:52.410 +Então você tem diferentes regiões que você aplica um específico? + +0:39:53.500,0:39:57.060 +Operador para aquela região específica, por exemplo, você tem a norma P + +0:39:58.150,0:39:59.680 +e então + +0:39:59.680,0:40:02.760 +Sim, o P vai para mais infinito. voce tem o maximo + +0:40:03.730,0:40:09.860 +E então esse não é dar-lhe um valor certo, então você dá um passo. + +0:40:09.860,0:40:12.840 +pule para Pixels ainda mais e então você novamente calcula a mesma coisa + +0:40:12.840,0:40:18.150 +você vai ter outro valor lá e assim sucessivamente até acabar de + +0:40:18.700,0:40:24.900 +Seus dados que eram m por n com canais c você ainda obtém canais c + +0:40:24.900,0:40:31.199 +Mas então, neste caso, você obterá m/2 ec e n/2. Ok, e isso é para imagens + +0:40:35.029,0:40:41.079 +Não há parâmetros no pool, como você pode escolher qual tipo de pooling, certo, você pode escolher o pool máximo + +0:40:41.390,0:40:44.229 +Agrupamento médio qualquer agrupamento está errado. assim + +0:40:45.769,0:40:48.879 +Sim, vamos também o problema, ok, então + +0:40:49.999,0:40:55.809 +Esta foi a parte média com os slides. Vamos ver agora os notebooks ficarão um pouco mais lentos desta vez + +0:40:55.809,0:40:58.508 +Percebi que da última vez eu meio que me apressei + +0:40:59.900,0:41:02.529 +Há alguma pergunta até agora sobre esta parte que abordamos? + +0:41:04.519,0:41:06.519 +Sim + +0:41:10.670,0:41:12.469 +Então existe como + +0:41:12.469,0:41:17.769 +Geoffrey Hinton é conhecido por dizer que o pooling máximo é algo que é apenas + +0:41:18.259,0:41:23.319 +Errado porque você apenas joga fora as informações como você calcula a média ou você pega o máximo, você apenas joga fora as coisas + +0:41:24.380,0:41:29.140 +Ele está trabalhando em algo chamado redes de cápsulas, que você conhece + +0:41:29.660,0:41:33.849 +caminhos de roteamento que estão escolhendo, você conhece alguns + +0:41:34.519,0:41:41.319 +Melhores estratégias para evitar como jogar fora informações. OK. Basicamente esse é o argumento por trás sim + +0:41:45.469,0:41:52.329 +Sim, então o objetivo principal de usar esse pooling ou o stride é, na verdade, livrar-se de muitos dados, de modo que você + +0:41:52.329,0:41:54.579 +Pode computar coisas em uma quantidade razoável de tempo? + +0:41:54.619,0:42:00.939 +Normalmente você precisa de muito passo ou pooling nas primeiras camadas na parte inferior porque, caso contrário, é absolutamente você saber + +0:42:01.339,0:42:03.339 +Muito caro computacionalmente + +0:42:03.979,0:42:05.979 +Sim + +0:42:21.459,0:42:23.459 +Então, naquele sentar + +0:42:24.339,0:42:32.068 +Essas arquiteturas de rede são até agora impulsionadas por você conhece o estado da arte, que é completamente uma base empírica + +0:42:33.279,0:42:40.109 +nós nos esforçamos e na verdade vamos para, quero dizer, agora chegamos a algum tipo de padrão, então um + +0:42:40.359,0:42:44.399 +Alguns anos atrás. Eu estava respondendo como se eu não soubesse, mas agora nós realmente temos + +0:42:45.099,0:42:47.049 +Determinado algumas boas configurações + +0:42:47.049,0:42:53.968 +Especialmente usando essas conexões de receptor e a normalização de lote. Na verdade, podemos treinar basicamente tudo + +0:42:54.759,0:42:56.759 +Sim + +0:43:05.859,0:43:11.038 +Então, basicamente, você terá seu gradiente em um ponto específico descendo também + +0:43:11.039,0:43:13.679 +E então você tem o outro gradiente descendo + +0:43:13.839,0:43:18.238 +Então você tinha uma ramificação certa uma ramificação e se tiver ramificação o que está acontecendo com o gradiente? + +0:43:19.720,0:43:25.439 +Está correto. Sim, eles são adicionados corretamente, então você tem os dois gradientes provenientes de dois ramos diferentes sendo adicionados juntos + +0:43:26.470,0:43:31.769 +Tudo bem. Então vamos ao caderno para que possamos cobrir não nos apressarmos muito + +0:43:32.859,0:43:37.139 +Então aqui eu apenas passo pela parte do convnet. Então aqui eu treino + +0:43:39.519,0:43:41.289 +Inicialmente eu + +0:43:41.289,0:43:43.979 +Carregue o conjunto de dados MNIST, então mostro alguns + +0:43:44.680,0:43:45.849 +personagens aqui + +0:43:45.849,0:43:52.828 +Ok, e eu treino agora um perceptron multicamada como uma rede totalmente conectada como um humor, você sabe + +0:43:53.440,0:44:00.509 +Sim, rede totalmente conectada e uma rede neural convolucional que possui o mesmo número de parâmetros. OK. Então esses dois modelos terão o mesmo + +0:44:01.150,0:44:05.819 +Dimensão em termos de D. Se você salvá-los vamos esperar o mesmo para + +0:44:07.269,0:44:11.219 +Estou treinando aqui esse cara aqui com a Rede totalmente conectada + +0:44:12.640,0:44:14.640 +Leva um pouco de tempo + +0:44:14.829,0:44:21.028 +E ele fica 87% bem. Isso é treinado na classificação dos dígitos MNIST de Yann + +0:44:21.999,0:44:24.419 +Na verdade, baixamos do site dele, se você verificar + +0:44:25.239,0:44:32.189 +De qualquer forma, eu treino uma rede neural convolucional com o mesmo número de parâmetros que você espera ter um resultado melhor ou pior + +0:44:32.349,0:44:35.548 +Então, meu perceptron multicamada obtém 87% + +0:44:36.190,0:44:38.190 +O que obtemos com uma rede convolucional? + +0:44:41.739,0:44:43.739 +Sim porque + +0:44:46.910,0:44:50.950 +Ok, então qual é o ponto aqui de usar esparsidade o que isso significa + +0:44:52.640,0:44:55.089 +Dado que temos o mesmo número de parâmetros + +0:44:56.690,0:44:58.690 +Conseguimos treinar muito + +0:44:59.570,0:45:05.440 +mais filtros certo no segundo caso porque no primeiro caso usamos filtros que estão tentando obter algum + +0:45:05.960,0:45:12.549 +dependências entre coisas que estão mais distantes com coisas que estão fechadas por isso são completamente desperdiçadas basicamente elas aprendem 0 + +0:45:12.830,0:45:19.930 +Em vez disso, na rede convolucional. Eu tenho todos esses parâmetros. Eles estão apenas concentrados para descobrir. Qual é a relação dentro de um + +0:45:20.480,0:45:23.799 +Pixels vizinhos. Tudo bem. Então agora ele tira as fotos que eu + +0:45:24.740,0:45:26.740 +Agite tudo acabou de ser mexido + +0:45:27.410,0:45:33.369 +Mas mantenho o mesmo embaralhe da mesma forma todas as imagens. Então eu executo uma permutação aleatória + +0:45:34.850,0:45:38.710 +Sempre a mesma permutação aleatória de todas as minhas imagens ou pixels nas minhas imagens + +0:45:39.500,0:45:41.090 +O que acontece? + +0:45:41.090,0:45:43.299 +Se eu treinar as duas redes + +0:45:47.990,0:45:50.049 +Então aqui eu treinei veja aqui + +0:45:50.050,0:45:56.950 +Eu tenho minhas imagens de fotos e aqui eu apenas embaralhei com a mesma função de embaralhamento todos os pixels + +0:46:00.200,0:46:04.240 +Todas as minhas entradas serão essas imagens aqui + +0:46:06.590,0:46:10.870 +A saída ainda será a classe do original, então este é um quatro você + +0:46:11.450,0:46:13.780 +Pode ver que isso é um quatro. Este é um nove + +0:46:14.920,0:46:19.889 +Este é um 1 este é um 7 é um 3 este é um 4 então eu mantenho os mesmos rótulos + +0:46:19.930,0:46:24.450 +Mas eu embaralhei a ordem dos pixels e executo o mesmo embaralhamento todas as vezes + +0:46:25.239,0:46:27.239 +O que você espera é desempenho? + +0:46:31.029,0:46:33.299 +Quem é melhor quem está trabalhando quem é o mesmo? + +0:46:38.619,0:46:46.258 +Percepção como faz com a percepção? Ele vê alguma diferença? Não, tudo bem. Então o cara ainda 83 + +0:46:47.920,0:46:49.920 +rede de Yann + +0:46:52.029,0:46:54.029 +O que vocês + +0:47:04.089,0:47:09.988 +Saiba que é um totalmente conectado. Desculpe. Vou mudar a ordem. Sim, veja. OK. Ai está + +0:47:12.460,0:47:14.999 +Então eu não posso nem te mostrar essa coisa + +0:47:17.920,0:47:18.730 +Tudo bem + +0:47:18.730,0:47:24.659 +Então, o cara totalmente conectado basicamente executou o mesmo, as diferenças são apenas básicas com base no inicial + +0:47:25.059,0:47:30.899 +A inicialização aleatória da rede convolucional que estava ganhando por meio de grande avanço + +0:47:31.509,0:47:33.509 +vantagem antes de realmente realizar + +0:47:34.059,0:47:38.008 +Tipo de cada um de forma semelhante, mas quero dizer pior do que muito pior do que antes + +0:47:38.499,0:47:42.449 +Por que a rede convolucional agora está tendo um desempenho pior do que minha rede totalmente conectada? + +0:47:44.829,0:47:46.829 +Porque nós fodemos + +0:47:47.739,0:47:55.379 +Ok, e toda vez que você usa uma rede convolucional, você realmente tem que pensar que posso usar uma rede convolucional, ok + +0:47:56.440,0:47:59.700 +Se valer agora, você tem as três propriedades, então sim + +0:47:59.700,0:48:05.759 +Talvez, é claro, devesse oferecer um desempenho melhor se essas três propriedades não se mantiverem + +0:48:06.579,0:48:09.058 +então usar redes convolucionais é + +0:48:11.499,0:48:17.939 +BS certo, qual foi o viés? Não. Ok. Deixa pra lá. Tudo bem. Bem boa noite \ No newline at end of file diff --git a/docs/pt/week04/04-1.md b/docs/pt/week04/04-1.md new file mode 100644 index 000000000..78ecbe56c --- /dev/null +++ b/docs/pt/week04/04-1.md @@ -0,0 +1,596 @@ +--- +lang: pt +lang-ref: ch.04-1 +lecturer: Alfredo Canziani +title: Álgebra Linear e Convoluções +authors: Yuchi Ge, Anshan He, Shuting Gu e Weiyang Wen +date: 18 Feb 2020 +translation-date: 05 Nov 2021 +translator: Leon Solon +--- + + + +## [Revisão de Álgebra Linear](https://www.youtube.com/watch?v=OrBEon3VlQg&t=68s) + + + +Esta parte é uma recapitulação de Álgebra Linear básica no contexto das redes neurais. Começamos com uma camada oculta simples $\boldsymbol{h}$: + + + +$$ +\boldsymbol{h} = f(\boldsymbol{z}) +$$ + + + +A saída é uma função não linear $f$ aplicada a um vetor $z$. Aqui $z$ é a saída de uma transformação afim (affine transformation) $\boldsymbol{A} \in\mathbb{R^{m\times n}}$ para o vetor de entrada $\boldsymbol{x} \in\mathbb{R^n}$: + + + +$$ +\boldsymbol{z} = \boldsymbol{A} \boldsymbol{x} +$$ + + + +Para simplificar, os viéses (biases) são ignorados. A equação linear pode ser expandida como: + + + +$$ +\boldsymbol{A}\boldsymbol{x} = +\begin{pmatrix} +a_{11} & a_{12} & \cdots & a_{1n}\\ +a_{21} & a_{22} & \cdots & a_{2n} \\ +\vdots & \vdots & \ddots & \vdots \\ +a_{m1} & a_{m2} & \cdots & a_{mn} \end{pmatrix} \begin{pmatrix} +x_1 \\ \vdots \\x_n \end{pmatrix} = +\begin{pmatrix} + \text{---} \; \boldsymbol{a}^{(1)} \; \text{---} \\ + \text{---} \; \boldsymbol{a}^{(2)} \; \text{---} \\ + \vdots \\ + \text{---} \; \boldsymbol{a}^{(m)} \; \text{---} \\ +\end{pmatrix} +\begin{matrix} + \rvert \\ \boldsymbol{x} \\ \rvert +\end{matrix} = +\begin{pmatrix} + {\boldsymbol{a}}^{(1)} \boldsymbol{x} \\ {\boldsymbol{a}}^{(2)} \boldsymbol{x} \\ \vdots \\ {\boldsymbol{a}}^{(m)} \boldsymbol{x} +\end{pmatrix}_{m \times 1} +$$ + + + +onde $\boldsymbol{a}^{(i)}$ é a $i$-ésima linha da matriz $\boldsymbol{A}$. + + + +Para entender o significado dessa transformação, vamos analisar um componente de $\boldsymbol{z}$ como $a^{(1)}\boldsymbol{x}$. Seja $n=2$, então $\boldsymbol{a} = (a_1,a_2)$ e $\boldsymbol{x} = (x_1,x_2)$. + + + +$\boldsymbol{a}$ e $\boldsymbol{x}$ podem ser desenhados como vetores no eixo de coordenadas 2D. Agora, se o ângulo entre $\boldsymbol{a}$ e $\hat{\boldsymbol{\imath}}$ é $\alpha$ e o ângulo entre $\boldsymbol{x}$ e $\hat{\boldsymbol{\imath}}$ é $\xi$, então com fórmulas trigonométricas $a^\top\boldsymbol{x}$ pode ser expandido como: + + + +$$ +\begin {aligned} +\boldsymbol{a}^\top\boldsymbol{x} &= a_1x_1+a_2x_2\\ +&=\lVert \boldsymbol{a} \rVert \cos(\alpha)\lVert \boldsymbol{x} \rVert \cos(\xi) + \lVert \boldsymbol{a} \rVert \sin(\alpha)\lVert \boldsymbol{x} \rVert \sin(\xi)\\ +&=\lVert \boldsymbol{a} \rVert \lVert \boldsymbol{x} \rVert \big(\cos(\alpha)\cos(\xi)+\sin(\alpha)\sin(\xi)\big)\\ +&=\lVert \boldsymbol{a} \rVert \lVert \boldsymbol{x} \rVert \cos(\xi-\alpha) +\end {aligned} +$$ + + + +A saída mede o alinhamento da entrada a uma linha específica da matriz $\boldsymbol{A}$. Isso pode ser entendido observando o ângulo entre os dois vetores, $\xi-\alpha$. Quando $\xi = \alpha$, os dois vetores estão perfeitamente alinhados e o máximo é atingido. Se $\xi - \alpha = \pi$, então $\boldsymbol{a}^\top\boldsymbol{x}$ atinge seu mínimo e os dois vetores estão apontando em direções opostas. Em essência, a transformação linear permite ver a projeção de uma entrada para várias orientações definidas por $A$. Essa intuição também pode ser expandida para dimensões superiores. + + + +Outra maneira de entender a transformação linear é entendendo que $\boldsymbol{z}$ também pode ser expandido como: + + + +$$ +\boldsymbol{A}\boldsymbol{x} = +\begin{pmatrix} + \vert & \vert & & \vert \\ + \boldsymbol{a}_1 & \boldsymbol{a}_2 & \cdots & \boldsymbol{a}_n \\ + \vert & \vert & & \vert \\ +\end{pmatrix} +\begin{matrix} + \rvert \\ \boldsymbol{x} \\ \rvert +\end{matrix} = +x_1 \begin{matrix} \rvert \\ \boldsymbol{a}_1 \\ \rvert \end{matrix} + +x_2 \begin{matrix} \rvert \\ \boldsymbol{a}_2 \\ \rvert \end{matrix} + + \cdots + +x_n \begin{matrix} \rvert \\ \boldsymbol{a}_n \\ \rvert \end{matrix} +$$ + + + +A saída é a soma ponderada das colunas da matriz $\boldsymbol{A}$. Portanto, o sinal nada mais é do que uma composição da entrada. + + + +## [Extender Álgebra Linear para convoluções](https://www.youtube.com/watch?v=OrBEon3VlQg&t=1030s) + + + +Agora estendemos a álgebra linear às convoluções, usando o exemplo de análise de dados de áudio. Começamos representando uma camada totalmente conectada como uma forma de multiplicação de matriz: - + + + +$$ +\begin{bmatrix} +w_{11} & w_{12} & w_{13}\\ +w_{21} & w_{22} & w_{23}\\ +w_{31} & w_{32} & w_{33}\\ +w_{41} & w_{42} & w_{43} +\end{bmatrix} +\begin{bmatrix} +x_1\\ +x_2\\ +x_3 +\end{bmatrix} = \begin{bmatrix} +y_1\\ +y_2\\ +y_3\\ +y_4 +\end{bmatrix} +$$ + + + +Neste exemplo, a matriz de peso tem um tamanho de $4 \times 3$, o vetor de entrada tem um tamanho de $3 \times 1$ e o vetor de saída tem um tamanho de $4 \times 1$. + + + +No entanto, para dados de áudio, os dados são muito mais longos (não com 3 amostras). O número de amostras nos dados de áudio é igual à duração do áudio (*por exemplo,* 3 segundos) vezes a taxa de amostragem (*por exemplo,* 22,05 kHz). Conforme mostrado abaixo, o vetor de entrada $\boldsymbol{x}$ será bem longo. Correspondentemente, a matriz de peso se tornará "gorda". + + + +$$ +\begin{bmatrix} +w_{11} & w_{12} & w_{13} & w_{14} & \cdots &w_{1k}& \cdots &w_{1n}\\ +w_{21} & w_{22} & w_{23}& w_{24} & \cdots & w_{2k}&\cdots &w_{2n}\\ +w_{31} & w_{32} & w_{33}& w_{34} & \cdots & w_{3k}&\cdots &w_{3n}\\ +w_{41} & w_{42} & w_{43}& w_{44} & \cdots & w_{4k}&\cdots &w_{4n} +\end{bmatrix} +\begin{bmatrix} +x_1\\ +x_2\\ +x_3\\ +x_4\\ +\vdots\\ +x_k\\ +\vdots\\ +x_n +\end{bmatrix} = \begin{bmatrix} +y_1\\ +y_2\\ +y_3\\ +y_4 +\end{bmatrix} +$$ + + + +A formulação acima será difícil de treinar. Felizmente, existem maneiras de simplificar o mesmo. + + + +### Propriedade: localidade + + + +Devido à localidade (*ou seja,* não nos importamos com pontos de dados distantes) dos dados, $ w_ {1k} $ da matriz de peso acima pode ser preenchido com 0 quando $ k $ é relativamente grande. Portanto, a primeira linha da matriz torna-se um kernel de tamanho 3. Vamos denotar este kernel de tamanho 3 como $\boldsymbol{a}^{(1)} = \begin{bmatrix} a_1^{(1)} & a_2^{(1)} & a_3^{(1)} \end{bmatrix}$. + + + +$$ +\begin{bmatrix} +a_1^{(1)} & a_2^{(1)} & a_3^{(1)} & 0 & \cdots &0& \cdots &0\\ +w_{21} & w_{22} & w_{23}& w_{24} & \cdots & w_{2k}&\cdots &w_{2n}\\ +w_{31} & w_{32} & w_{33}& w_{34} & \cdots & w_{3k}&\cdots &w_{3n}\\ +w_{41} & w_{42} & w_{43}& w_{44} & \cdots & w_{4k}&\cdots &w_{4n} +\end{bmatrix} +\begin{bmatrix} +x_1\\ +x_2\\ +x_3\\ +x_4\\ +\vdots\\ +x_k\\ +\vdots\\ +x_n +\end{bmatrix} = \begin{bmatrix} +y_1\\ +y_2\\ +y_3\\ +y_4 +\end{bmatrix} +$$ + + + +### Propriedade: estacionariedade + + + +Os sinais de dados naturais têm a propriedade de estacionariedade (*ou seja,* certos padrões / motivos se repetirão). Isso nos ajuda a reutilizar o kernel $\mathbf{a}^{(1)}$ que definimos anteriormente. Usamos este kernel colocando-o um passo adiante a cada vez (*ou seja,* o passo é 1), resultando no seguinte: + + + +$$ +\begin{bmatrix} +a_1^{(1)} & a_2^{(1)} & a_3^{(1)} & 0 & 0 & 0 & 0&\cdots &0\\ +0 & a_1^{(1)} & a_2^{(1)} & a_3^{(1)} & 0&0&0&\cdots &0\\ +0 & 0 & a_1^{(1)} & a_2^{(1)} & a_3^{(1)} & 0&0&\cdots &0\\ +0 & 0 & 0& a_1^{(1)} & a_2^{(1)} &a_3^{(1)} &0&\cdots &0\\ +0 & 0 & 0& 0 & a_1^{(1)} &a_2^{(1)} &a_3^{(1)} &\cdots &0\\ +\vdots&&\vdots&&\vdots&&\vdots&&\vdots +\end{bmatrix} +\begin{bmatrix} +x_1\\ +x_2\\ +x_3\\ +x_4\\ +\vdots\\ +x_k\\ +\vdots\\ +x_n +\end{bmatrix} +$$ + + + +Tanto a parte superior direita quanto a parte inferior esquerda da matriz são preenchidas com $ 0 $ s graças à localidade, levando à dispersão. A reutilização de um determinado kernel repetidamente é chamada de divisão de peso. + + + +### Múltiplas camadas de matriz Toeplitz + + + +Após essas alterações, o número de parâmetros que resta é 3 (*ou seja,* $a_1,a_2,a_3$). Em comparação com a matriz de peso anterior, que tinha 12 parâmetros (*por exemplo* $w_{11},w_{12},\cdots,w_{43}$), o número atual de parâmetros é muito restritivo e gostaríamos de expandir o mesmo. + + + +A matriz anterior pode ser considerada uma camada (*ou seja,* uma camada convolucional) com o kernel $\boldsymbol{a}^{(1)}$. Então podemos construir múltiplas camadas com diferentes kernels $\boldsymbol{a}^{(2)}$, $\boldsymbol{a}^{(3)}$, etc, aumentando assim os parâmetros. + + + +Cada camada possui uma matriz contendo apenas um kernel que é replicado várias vezes. Este tipo de matriz é denominado matriz de Toeplitz. Em cada matriz de Toeplitz, cada diagonal descendente da esquerda para a direita é constante. As matrizes Toeplitz que usamos aqui também são matrizes esparsas. + + + +Dado o primeiro kernel $\boldsymbol{a}^{(1)}$ e o vetor de entrada $\boldsymbol{x}$, a primeira entrada na saída fornecida por esta camada é, $a_1^{(1)} x_1 + a_2^{(1)} x_2 + a_3^{(1)}x_3$. Portanto, todo o vetor de saída se parece com o seguinte: - + + + +$$ +\begin{bmatrix} +\mathbf{a}^{(1)}x[1:3]\\ +\mathbf{a}^{(1)}x[2:4]\\ +\mathbf{a}^{(1)}x[3:5]\\ +\vdots +\end{bmatrix} +$$ + + + +O mesmo método de multiplicação de matriz pode ser aplicado nas seguintes camadas convolucionais com outros kernels (*por exemplo* $\boldsymbol{a}^{(2)}$ e $\boldsymbol{a}^{(3)}$) para obter similar resultados. + + + +## [Ouvindo as convoluções - Jupyter Notebook](https://www.youtube.com/watch?v=OrBEon3VlQg&t=1709s) + + + +O Jupyter Notebook pode ser encontrado [aqui](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/07-listening_to_kernels.ipynb). + + + +Neste bloco de notas, vamos explorar a Convolução como um 'produto escalar em execução'. + + + +A biblioteca `librosa` nos permite carregar o clipe de áudio $\boldsymbol{x}$ e sua taxa de amostragem. Nesse caso, existem 70641 amostras, a taxa de amostragem é de 22,05 kHz e a duração total do clipe é de 3,2 s. O sinal de áudio importado é ondulado (consulte a Figura 1) e podemos adivinhar como ele soa a partir da amplitude do eixo $ y $. O sinal de áudio $x(t)$ é na verdade o som reproduzido ao desligar o sistema Windows (consulte a Fig 2). + + + +
+
+Fig. 1: Uma visualização do sinal de áudio.
+
+ + + +
+
+Fig. 2: Observações para o sinal de áudio acima.
+
+ + + +Precisamos separar as notas da forma de onda. Para conseguir isso, se usarmos a transformada de Fourier (FT), todas as notas sairão juntas e será difícil descobrir a hora exata e a localização de cada afinação. Portanto, um FT localizado é necessário (também conhecido como espectrograma). Como é observado no espectrograma (consulte a Fig. 3), diferentes tons de pico em diferentes frequências (*por exemplo* primeiros picos de tom em 1600). A concatenação dos quatro tons em suas frequências nos dá uma versão do sinal original. + + + +
+
+Fig. 3: Sinal de áudio e seu espectrograma.
+
+ + + +A convolução do sinal de entrada com todos os tons (todas as teclas do piano, por exemplo) pode ajudar a extrair todas as notas na peça de entrada (*ou seja,* os hits quando o áudio corresponde aos núcleos específicos). Os espectrogramas do sinal original e o sinal dos tons concatenados são mostrados na Fig. 4, enquanto as frequências do sinal original e os quatro tons são mostrados na Fig. 5. O gráfico das convoluções dos quatro núcleos com o sinal de entrada (original sinal) é mostrado na Fig 6. A Fig 6 junto com os clipes de áudio das convoluções comprovam a eficácia das convoluções na extração das notas. + + + +
+
+Fig. 4: Espectrograma do sinal original (esquerda) e Espectrograma da concatenação de tons (direita).
+
+ + + +
+
+Fig. 5: Primeira nota da melodia.
+
+ + + +
+
+Fig. 6: Convolução de quatro grãos.
+
+ + + +## Dimensionalidade de diferentes conjuntos de dados + + + +A última parte é uma pequena digressão sobre as diferentes representações da dimensionalidade e exemplos para as mesmas. Aqui, consideramos que o conjunto de entrada $X$ é feito de mapeamento de funções dos domínios $\Omega$ para os canais $c$. + + + +### Exemplos + + + +* Dados de áudio: o domínio é 1-D, sinal discreto indexado pelo tempo; o número de canais $ c $ pode variar de 1 (mono), 2 (estéreo), 5 + 1 (Dolby 5.1), *etc.* +* Dados da imagem: o domínio é 2-D (pixels); $ c $ pode variar de 1 (escala de cinza), 3 (cor), 20 (hiperespectral), *etc.* +* Relatividade especial: o domínio é $\mathbb{R^4} \times \mathbb{R^4}$ (espaço-tempo $\times$ quatro-momento); quando $c = 1$ é chamado de Hamiltoniano. + + + +
+
+Fig. 7: Dimensões diferentes de tipos diferentes de sinais.
+
diff --git a/docs/pt/week04/04.md b/docs/pt/week04/04.md new file mode 100644 index 000000000..942afab61 --- /dev/null +++ b/docs/pt/week04/04.md @@ -0,0 +1,18 @@ +--- +lang: pt +lang-ref: ch.04 +title: Semana 4 +translation-date: 05 Nov 2021 +translator: Leon Solon +--- + + + +## Prática + + + +Começamos com uma breve revisão de Álgebra Linear e, em seguida, estendemos o tópico para as convoluções usando dados de áudio como exemplo. Conceitos chave como localidade, estacionariedade e matriz de Toeplitz são reiterados. Em seguida, oferecemos uma demonstração ao vivo do desempenho da convolução na análise do tom. Finalmente, há uma pequena digressão sobre a dimensionalidade de diferentes dados. \ No newline at end of file diff --git a/docs/pt/week04/practicum04.sbv b/docs/pt/week04/practicum04.sbv new file mode 100644 index 000000000..5b8ec5afc --- /dev/null +++ b/docs/pt/week04/practicum04.sbv @@ -0,0 +1,1517 @@ +0:00:00.030,0:00:04.730 +então, desde a última vez, ok, bem-vindo de volta, obrigado por estar aqui. + +0:00:04.730,0:00:09.059 +A última vez que Yann usou o tablet, certo? e como você pode usar o tablet e eu + +0:00:09.059,0:00:13.040 +não usa o tablet, certo? Então, eu deveria ser tão legal quanto Yann, pelo menos eu acho. + +0:00:13.040,0:00:18.900 +Mais uma coisa para começar, há uma planilha onde você pode decidir se + +0:00:18.900,0:00:22.890 +você gostaria de entrar no canal do Slack, onde colaboramos para fazer + +0:00:22.890,0:00:28.529 +alguns desenhos para o site, corrigindo algumas notações matemáticas, tendo alguns + +0:00:28.529,0:00:32.640 +tipo de, você sabe, consertar o erro em inglês na gramática inglesa ou + +0:00:32.640,0:00:37.290 +seja o que for, então, se você estiver interessado em ajudar a melhorar o conteúdo de + +0:00:37.290,0:00:42.450 +esta turma, fique à vontade para preencher a planilha, ok? Já somos alguns de + +0:00:42.450,0:00:49.789 +nós no canal do Slack, então quero dizer, se você quiser entrar, de nada. Então + +0:00:49.789,0:00:53.399 +em vez de escrever no quadro branco, porque é impossível ver, eu acho + +0:00:53.399,0:01:00.270 +do lado superior, vamos experimentar um novo brinquedo aqui. Tudo + +0:01:00.270,0:01:03.930 +direito. Primeira vez, então você sabe, estou um pouco + +0:01:03.930,0:01:11.250 +tenso. Da última vez, estraguei um notebook, então tudo bem, tudo bem. Então nós vamos + +0:01:11.250,0:01:15.659 +comece com uma pequena revisão sobre álgebra linear. Espero que não seja + +0:01:15.659,0:01:20.670 +ofender alguém, estou ciente de que você já estudou álgebra linear e está + +0:01:20.670,0:01:25.920 +muito forte nisso, mas, no entanto, gostaria de lhe fornecer minha intuição, meu + +0:01:25.920,0:01:31.320 +perspectiva, ok? é apenas um slide, não muito, então talvez você queira + +0:01:31.320,0:01:36.290 +para tirar papel e caneta ou você pode apenas saber, o que for, acompanhar. + +0:01:36.290,0:01:49.850 +Portanto, esta será uma revisão de álgebra linear. + +0:01:51.170,0:02:06.450 +OK. Estou esperando um pouco? Deixe-me esperar um segundo. Preparar?? Sim? Não? mexa sua + +0:02:06.450,0:02:12.150 +cabeça. Fantástico, certo, estávamos conversando da última vez que tivemos um + +0:02:12.150,0:02:15.270 +rede com a entrada na parte inferior, então tínhamos um afim + +0:02:15.270,0:02:18.510 +transformação, então temos uma camada oculta à direita. Então, vou apenas escrever o + +0:02:18.510,0:02:23.280 +primeira equação. Teremos essa minha camada oculta, e como estou escrevendo + +0:02:23.280,0:02:26.970 +com uma caneta, você pode ver alguma coisa? sim? então, como estou escrevendo com uma caneta, estou + +0:02:26.970,0:02:30.360 +vai colocar um sublinhado embaixo da variável para + +0:02:30.360,0:02:35.120 +indicam que é um vetor. OK? é assim que escrevo vetores. Então meu H vai ser um + +0:02:35.120,0:02:42.660 +função não linear f aplicada ao meu z e z vai ser minha entrada linear, + +0:02:42.660,0:02:46.230 +a saída da transformação afim, portanto, neste caso + +0:02:46.230,0:02:54.989 +Vou escrever aqui z será igual à minha matriz A vezes x. Nós + +0:02:54.989,0:03:00.630 +podemos imaginar que não há preconceito neste caso, é genérico o suficiente porque podemos + +0:03:00.630,0:03:06.030 +inclua o viés dentro da matriz e tenha o primeiro item de x igual a + +0:03:06.030,0:03:18.360 +1. Então, se este x aqui pertence a R n e este z aqui pertence a R m, a primeira pergunta: + +0:03:18.360,0:03:24.989 +qual é o tamanho desta matriz? Ok, fantástico, então esta matriz aqui é + +0:03:24.989,0:03:30.360 +vai ser o nosso m vezes n, você tem tantas linhas quanto a dimensão para onde você atira + +0:03:30.360,0:03:34.200 +e você tem tantas colunas quanto a dimensão de onde você está filmando, ok? + +0:03:34.200,0:03:39.930 +Tudo bem, então vamos expandir este, então esta matriz aqui vai ser igual a + +0:03:39.930,0:03:49.549 +o que você tem a_ {1,1} a_ {1,2} assim por diante até o último, qual vai ser? gritar. + +0:03:49.549,0:03:56.269 +Obrigado, 1 ...? sim 1 e então você tem o segundo + +0:03:56.269,0:04:04.249 +vai ter a_ {2,1} a_ {2,2} assim por diante até o último que é a {2, n}, certo? e aí você + +0:04:04.249,0:04:14.840 +continuar descendo até o último qual vai ser? quais são os índices? m 1, + +0:04:14.840,0:04:24.740 +direito? Ok, então você tem a_ {m, 1}, a_ {m, 2} e assim por diante até a_ {m, n}, ok, obrigado. + +0:04:24.740,0:04:37.220 +E então temos aqui o nosso x, certo? então você tem x_1, x_2 e assim por diante até x_n, + +0:04:37.220,0:04:39.490 +direito? + +0:04:41.680,0:04:47.479 +Você está mais responsivo do que no ano passado, ótimo, obrigado. Tudo bem, então nós também podemos + +0:04:47.479,0:04:52.099 +reescrever este de maneiras diferentes. Então, a primeira maneira que vou escrever este + +0:04:52.099,0:05:00.020 +será o seguinte, então terei aqui estes 1, então terei + +0:05:00.020,0:05:12.409 +aqui meu a 2 e então eu tenho o último que vai ser meu an, ok? e então + +0:05:12.409,0:05:15.800 +aqui vou multiplicar isso por um vetor de coluna, certo? então meu vetor de coluna + +0:05:15.800,0:05:23.409 +Eu vou escrever assim. Tudo bem, então qual é o resultado desta operação? + +0:05:23.409,0:05:28.820 +então essas são métricas, você tem um vetor, o resultado será um? vetor. Então + +0:05:28.820,0:05:35.780 +qual vai ser o primeiro item do meu vetor? Eu não uso pontos porque eu não sou + +0:05:35.780,0:05:40.219 +um físico, na verdade eu sou, mas estamos fazendo álgebra linear, então o que devo + +0:05:40.219,0:05:42.400 +escrever? + +0:05:43.810,0:05:47.509 +Tudo bem, isso já foi transposto porque esses são um vetor linha, então eu apenas + +0:05:47.509,0:05:54.979 +escreva um Eu vou dizer apenas certo então eu tenho um 1 x ok então não há + +0:05:54.979,0:06:02.780 +transposição aqui, sem pontos ao redor e assim por diante. O segundo elemento vai ser? um 2, ok, + +0:06:02.780,0:06:12.970 +xe então até o último qual vai ser? ok, não há ponto, mas com certeza. + +0:06:12.970,0:06:17.810 +Como se alguém estivesse chamando aquele produto escalar em vez de produto vetorial, mas isso é + +0:06:17.810,0:06:20.389 +assume que você usa um tipo diferente de notação. + +0:06:20.389,0:06:26.710 +Tudo bem, então esse será o meu, quantos elementos esse vetor tem? + +0:06:26.710,0:06:35.120 +estou bem, então temos z 1, z 2 e assim por diante até zm e este é meu conjunto final, certo? + +0:06:35.120,0:06:39.710 +meu vetor z, ok? Fantástico. Agora vamos nos concentrar um pouco + +0:06:39.710,0:06:48.590 +sobre o significado dessa coisa aqui ok, outras perguntas até agora? + +0:06:48.590,0:06:54.530 +tudo bem, isso é muito trivial até agora, espero, quero dizer, deixe-me saber se não, ok + +0:06:54.530,0:07:00.140 +então vamos analisar um desses caras aqui, então eu gostaria de descobrir o que é + +0:07:00.140,0:07:10.970 +o significado de escrever um T vezes x certo, então meu a T será meu ai genérico, então + +0:07:10.970,0:07:24.680 +vamos supor, neste caso, quando n é igual a 2, certo? Então, o que é um T x? então um T x está indo + +0:07:24.680,0:07:29.780 +ser igual a quê? então deixe-me desenhar aqui algo para que seja mais fácil para + +0:07:29.780,0:07:37.720 +você entender. Então este vai ser meu a, esses vão ser meu alfa e + +0:07:37.720,0:07:48.620 +então aqui você tem como se fosse meu x e isso vai ser aqui meu xi, então + +0:07:48.620,0:07:57.430 +qual é a saída deste produto aqui? Este aqui. + +0:07:58.210,0:08:08.470 +Diga novamente, desculpe. Uma transposição, vamos chamá-la, digamos que é um vetor linha + +0:08:10.030,0:08:27.880 +Você pode ver? não? qual vai ser o resultado desta operação aqui? não por que? + +0:08:29.410,0:08:34.610 +Isso é como um genérico de muitos a's, certo? há muitos, + +0:08:34.610,0:08:39.169 +este é um daqueles m a's, então estou multiplicando um daqueles a's vezes meu x + +0:08:39.169,0:08:43.310 +certo, vamos supor que existam apenas duas dimensões, então qual será a + +0:08:43.310,0:08:50.660 +saída deste produto escalar? alguem pode me dizer? não não não normal + +0:08:50.660,0:09:02.720 +produto escalar. Espere então você tem um aqui, você tem + +0:09:02.720,0:09:08.510 +aqui, essa parte aqui vai ser 1, vai ser 2, certo? então você tem + +0:09:08.510,0:09:18.550 +aqui x 1 e agora você tem x 2, certo? então, como você expressa este produto escalar aqui? + +0:09:19.980,0:09:26.730 +ok, então estou apenas escrevendo, deixe-me saber se está tudo claro, então vou escrever aqui: + +0:09:28.890,0:09:37.780 +a 1 vezes x 1 mais a 2 vezes x 2, certo? esta é a definição. Claro, certo? Então + +0:09:37.780,0:09:44.830 +longe né? não? ok, sim, pergunta sim. Isso é para ser uma transposição. Uma fila + +0:09:44.830,0:09:49.600 +vetor de coluna de vezes, então vamos assumir que a é um vetor de coluna, então eu tenho tempos de linha + +0:09:49.600,0:10:02.230 +coluna. Então, vamos continuar escrevendo essas coisas aqui, então o que é 1? Como posso + +0:10:02.230,0:10:15.220 +computar 1? Repita? ok ok Então, vou escrever aqui que a 1 está indo + +0:10:15.220,0:10:20.770 +sendo o comprimento do vetor a vezes o cosseno alfa, então o que dizer de x 1? alguém + +0:10:20.770,0:10:30.010 +outro. O mesmo certo? Não, espere, o quê? o que é x 1? mesma coisa, certo, diferente + +0:10:30.010,0:10:37.450 +cartas. então alguém fala algo. Você está seguindo, você está completamente confuso, + +0:10:37.450,0:10:43.210 +você não está tendo ideia, é muito fácil? Não tenho ideia do que está acontecendo aqui. Isso é + +0:10:43.210,0:10:53.770 +boa direita? até agora ok? qual vai ser o segundo mandato? Este vai ser x + +0:10:53.770,0:11:00.430 +aqui né? vezes cos xi certo, e então você tinha o segundo termo que vai ser + +0:11:00.430,0:11:13.920 +que? magnitude de um ... grito, não consigo ouvir. Ok, seno de alfa e então + +0:11:17.660,0:11:21.290 +ok obrigado ok + +0:11:23.930,0:11:27.870 +tudo bem, vou apenas juntar aqueles dois caras, então você vai + +0:11:27.870,0:11:40.370 +obter igual magnitude de uma magnitude de vezes de x vezes cosseno alfa cosseno Xi mais + +0:11:40.370,0:11:48.210 +seno alfa e seno, cosseno, seno Xi, desculpe. + +0:11:48.210,0:11:54.210 +o que é o material entre parênteses? tudo bem, então é o cosseno do + +0:11:54.210,0:11:57.240 +diferença dos dois ângulos certo? todo mundo sabe trigonometria aqui, certo? + +0:11:57.240,0:12:05.160 +então, coisas do ensino médio, então este será igual a machado vezes o cosseno + +0:12:05.160,0:12:11.000 +de cos xi menos alfa, certo? ou o contrário, alfa menos xi. + +0:12:11.000,0:12:17.040 +Então o que isso quer dizer? Você pode pensar em cada elemento. até agora está claro? eu + +0:12:17.040,0:12:22.680 +não fez nenhuma mágica, sim, sacuda a cabeça assim para sim, isso para não, isso + +0:12:22.680,0:12:27.810 +porque talvez nada esteja funcionando. Ok, então você pode pensar sempre que quiser + +0:12:27.810,0:12:33.600 +multiplique uma matriz por um vetor que basicamente cada saída desta operação + +0:12:33.600,0:12:39.570 +vai medir, então ok espere um pouco, o que é esse cosseno? quanto é cosseno + +0:12:39.570,0:12:45.780 +de zero? 1. Então, isso significa que se esses dois ângulos, se os dois vetores estiverem alinhados, + +0:12:45.780,0:12:50.460 +o que significa que há um ângulo zero entre os dois vetores, você pode ter o + +0:12:50.460,0:12:57.090 +valor máximo desse elemento, certo? sempre que você tiver o menos o + +0:12:57.090,0:13:03.240 +valor mais negativo? quando eles são opostos, certo? então quando eles estão em + +0:13:03.240,0:13:08.310 +oposição de fase, você obterá a magnitude mais negativa, mas se você + +0:13:08.310,0:13:11.730 +aplique apenas digamos um ReLU, você vai cortar todas as coisas negativas que você está apenas + +0:13:11.730,0:13:16.200 +verificando as correspondências positivas, então a rede neural basicamente apenas talvez + +0:13:16.200,0:13:20.520 +vai descobrir apenas as correspondências positivas, certo? e então novamente quando + +0:13:20.520,0:13:23.620 +você multiplica uma matriz por um vetor de coluna que você + +0:13:23.620,0:13:31.330 +estar realizando um produto escalar lamentável em termos de elemento entre cada coluna, cada linha de + +0:13:31.330,0:13:36.220 +a matriz que representa o seu kernel certo? então, sempre que você tiver um + +0:13:36.220,0:13:40.000 +camada seu kernel vai ser toda a linha da matriz e agora você vê o que + +0:13:40.000,0:13:47.050 +é a projeção dessa entrada nessa coluna, quero dizer, na entrada dessa linha + +0:13:47.050,0:13:52.900 +direito? então cada elemento deste produto vai lhe dizer o alinhamento com + +0:13:52.900,0:13:57.580 +qual a entrada é qual é o alinhamento da entrada em relação ao + +0:13:57.580,0:14:04.600 +linha específica da matriz ok? sim? não? isso deve moldar um pouco mais como + +0:14:04.600,0:14:08.290 +intuição, enquanto usamos essas transformações lineares, elas são como + +0:14:08.290,0:14:13.140 +permitindo que você veja a projeção da entrada em diferentes tipos de + +0:14:13.140,0:14:22.300 +orientações digamos assim. Certo? você pode tentar saber extrapolar isso em + +0:14:22.300,0:14:26.140 +dimensões altas, eu acho que a intuição pelo menos eu posso dar a você funciona + +0:14:26.140,0:14:30.580 +definitivamente em duas e três dimensões, em dimensões superiores eu meio que acho + +0:14:30.580,0:14:34.209 +funciona de maneira semelhante. próxima lição que vamos assistir, na verdade somos nós + +0:14:34.209,0:14:38.890 +vamos ver como qual é a distribuição das projeções em um + +0:14:38.890,0:14:43.240 +espaço dimensional mais alto é esse tipo que vai ser tão legal, eu acho. tudo bem então + +0:14:43.240,0:14:49.779 +essa foi a primeira parte de eu penso na aula ah bem, tem mais uma + +0:14:49.779,0:14:54.940 +parte, então na verdade aqui este z aqui também podemos escrever de uma maneira diferente, + +0:14:54.940,0:15:00.130 +talvez isso seja talvez seja conhecido talvez não seja conhecido. quando eu vi pela primeira vez + +0:15:00.130,0:15:05.050 +Eu não sabia, então você sabe que é legal às vezes você ver essas coisas uma vez + +0:15:05.050,0:15:10.450 +de novo talvez então vamos voltar aqui é o mesmo z ali e então você pode expressar + +0:15:10.450,0:15:18.820 +este z como sendo igual ao vetor a 1, neste caso a 1 será o primeiro + +0:15:18.820,0:15:22.830 +coluna da matriz a ok e esta vai ser multiplicada pelo escalar + +0:15:22.830,0:15:29.380 +x1 agora você tem a segunda coluna da matriz, então eu tenho um 2 que é multiplicado + +0:15:29.380,0:15:34.870 +pelo segundo elemento do X à direita até o último qual vai ser? + +0:15:34.870,0:15:44.930 +novamente? Não consigo ouvir se é m ou n? m? assim? ou n? você conhece a linguagem de sinais? que + +0:15:44.930,0:15:52.880 +1? n? certo, você conhece a linguagem de sinais? não? você deve aprender que é bom, sabe? + +0:15:52.880,0:15:59.630 +inclusividade. um certo? então a última coluna vezes seu xn, é claro porque x + +0:15:59.630,0:16:04.100 +tem um tamanho de n, existem n itens, certo? e então basicamente quando você também quando você + +0:16:04.100,0:16:07.940 +faça uma transformação linear ou aplique um operador linear + +0:16:07.940,0:16:12.890 +vão pesar basicamente cada coluna da matriz com o coeficiente que + +0:16:12.890,0:16:16.640 +está em um, você sabe, você tem a primeira coluna vezes o primeiro coeficiente do + +0:16:16.640,0:16:22.130 +vetor, segunda coluna e pelo segundo item, mais a terceira coluna vezes o terceiro + +0:16:22.130,0:16:26.420 +item e, portanto, você pode ver que a saída dessa transformação de DN é uma soma ponderada + +0:16:26.420,0:16:32.180 +das colunas da matriz a ok? então este é um tipo diferente de intuição + +0:16:32.180,0:16:36.620 +às vezes você vê isso como se você quisesse expressar seu sinal, seu + +0:16:36.620,0:16:45.290 +dados são uma combinação de diferentes, você sabe, a composição, isso é uma espécie de + +0:16:45.290,0:16:50.600 +composição linear de sua entrada. tudo bem então essa foi a primeira parte, é o + +0:16:50.600,0:16:57.530 +recapitulação sobre a álgebra linear. uma segunda parte vai ser algo ainda mais + +0:16:57.530,0:17:06.790 +legal eu acho. perguntas até agora? não? fácil? muito fácil? você está ficando entediado? + +0:17:06.790,0:17:10.670 +desculpe ok tudo bem então eu vou acelerar eu acho. + +0:17:10.670,0:17:15.170 +tudo bem, então vamos ver como podemos estender o que as coisas que vimos + +0:17:15.170,0:17:19.040 +agora para as convoluções certas, então talvez as convoluções às vezes sejam um pouco + +0:17:19.040,0:17:28.900 +estranho, vamos ver como podemos fazer uma extensão para convoluções + +0:17:31.720,0:17:38.390 +tudo bem. então, digamos que eu comece com a mesma matriz. então vou ter aqui quatro + +0:17:38.390,0:17:53.660 +linhas e, em seguida, três colunas. Certo. então meus dados têm que ser? se eu tenho, se eu tenho isso + +0:17:53.660,0:17:59.360 +matriz, se eu multiplicar isso por uma coluna, meu vetor de coluna deve ser? do tamanho? três, + +0:17:59.360,0:18:04.250 +obrigada. tudo bem, deixe-me desenhar aqui meu vetor de coluna de tamanho três e este + +0:18:04.250,0:18:08.809 +vai te dar uma saída de tamanho quatro ok fantástico + +0:18:08.809,0:18:15.740 +mas então são seus dados, digamos que você vai ouvir um bom áudio, áudio + +0:18:15.740,0:18:21.260 +arquivo, seus dados têm apenas três amostras de comprimento? quanto tempo vão ficar seus dados? Digamos + +0:18:21.260,0:18:24.590 +você ouvindo uma música que dura três minutos + +0:18:24.590,0:18:32.330 +quantas amostras tem três minutos de áudio? sim, eu acho, o que é + +0:18:32.330,0:18:40.070 +vai ser minha taxa de amostragem? digamos vinte e dois, ok. vinte e dois mil quilos + +0:18:40.070,0:18:46.480 +Hertz, certo? 22 quilohertz então quantas amostras de três minutos de música tem? + +0:18:47.799,0:18:58.010 +Repita? Tem certeza que? é monofônico ou estereofônico? estou brincando. OK, então + +0:18:58.010,0:19:02.650 +você vai multiplicar o número de amostras, o número de segundos, certo? a + +0:19:02.650,0:19:08.660 +número de segundos vezes a taxa de quadros, certo? ok, a frequência neste + +0:19:08.660,0:19:12.620 +caso. de qualquer forma, esse sinal vai ser muito, muito longo, certo? vai ser mantido + +0:19:12.620,0:19:16.940 +indo para baixo, então se eu tiver um vetor que é muito, muito longo, eu tenho que usar um + +0:19:16.940,0:19:23.540 +matriz que vai ficar muito, muito gorda, larga, certo? ok fantástico então este top + +0:19:23.540,0:19:27.080 +continua indo nessa direção, tudo bem, então minha pergunta para você vai + +0:19:27.080,0:19:31.540 +ser o que devo colocar neste local aqui? + +0:19:35.570,0:19:48.020 +o que devo colocar aqui? então, nós nos importamos com coisas que estão mais distantes? + +0:19:48.740,0:19:54.000 +Não porque não? porque nossos dados têm a propriedade de + +0:19:54.000,0:20:00.299 +localidade, fantástica. então o que vou fazer o que vou colocar aqui? Uma grande + +0:20:00.299,0:20:06.690 +zero, certo, fantástico, bom trabalho, ok então colocamos um zero aqui e então qual é o outro + +0:20:06.690,0:20:09.809 +propriedade, então deixe-me começar a desenhar essas coisas novamente para que eu possa ter meu + +0:20:09.809,0:20:16.890 +kernel de tamanho três e aqui estou meus dados que serão muito longos + +0:20:16.890,0:20:31.169 +direito? e assim por diante. Não posso desenhar, espere. Eu não consigo ver Tudo bem, então aqui há zero, então vamos dizer o que + +0:20:31.169,0:20:36.960 +é a outra propriedade que meus dados naturais têm? estacionariedade, que + +0:20:36.960,0:20:45.059 +meios? o padrão que você espera encontrar pode ser uma espécie de repetição + +0:20:45.059,0:20:49.140 +e de novo certo? e então se eu tiver aqui meus três valores aqui talvez eu + +0:20:49.140,0:20:53.789 +gostaria de reutilizá-los uma e outra vez, certo? e então, se esses três valores permitirem + +0:20:53.789,0:21:00.779 +eu mude a cor talvez para que você possa ver que há a mesma coisa. então eu tenho + +0:21:00.779,0:21:07.230 +três valores aqui e então vou usar esses três mesmos valores em uma etapa + +0:21:07.230,0:21:16.770 +mais, certo? e eu continuo descendo e continuo assim + +0:21:16.770,0:21:22.799 +direito. Então, o que devo colocar aqui no fundo? O que devo colocar aqui? um zero, + +0:21:22.799,0:21:28.529 +direito? por que isso por que isso? devido à localidade dos dados. direito? tão colocando + +0:21:28.529,0:21:36.350 +zeros ao redor é chamado também é chamado de preenchimento, mas neste caso é chamado + +0:21:36.350,0:21:44.850 +esparsidade, certo? então isso é como esparsidade e, em seguida, a replicação dessa coisa + +0:21:44.850,0:21:52.730 +isso é repetidamente chamado de estacionariedade era a propriedade + +0:21:52.730,0:21:57.430 +do sinal, isso é chamado de divisão de peso. sim? + +0:22:04.330,0:22:10.090 +ok fantástico tudo bem então quantos valores nós temos agora? quantos + +0:22:10.090,0:22:13.530 +parâmetros que tenho do lado direito? + +0:22:15.150,0:22:22.750 +bem, então temos três parâmetros. No lado esquerdo, ao invés, nós + +0:22:22.750,0:22:28.900 +teve? Doze, certo? então o lado direito vai ser, o lado direito vai ser + +0:22:28.900,0:22:36.810 +trabalhar em tudo? você tem três parâmetros de um lado do outro lado você tem 12. + +0:22:36.810,0:22:41.860 +OK? isso é bom, usando localidade e qualquer coisa diferente de dispersão + +0:22:41.860,0:22:45.610 +e compartilhamento de parâmetros, mas acabamos com apenas três parâmetros, não é + +0:22:45.610,0:22:51.190 +isso é muito restritivo? como podemos ter vários parâmetros múltiplos? o que é + +0:22:51.190,0:22:56.290 +faltando aqui no quadro geral? existem vários canais, certo? então isso é + +0:22:56.290,0:23:01.570 +apenas uma camada aqui e então você tem essas coisas saindo do + +0:23:01.570,0:23:08.230 +placa aqui, então você tem o primeiro kernel aqui, agora você tem algum + +0:23:08.230,0:23:20.500 +segundo kernel, digamos este, e eu tenho o último aqui, certo? e então você tem + +0:23:20.500,0:23:24.760 +cada plano dessas métricas contendo apenas um kernel que é + +0:23:24.760,0:23:36.190 +replicado várias vezes. Quem sabe o nome desta matriz? então isso vai + +0:23:36.190,0:23:40.650 +ser chamada de matriz Toeplitz + +0:23:43.419,0:23:48.219 +Certo? então qual é a principal característica dessas matrizes Toeplitz? qual é o grande + +0:23:48.219,0:24:01.479 +grande coisa que você não notará? é uma matriz esparsa. ok ok o que vai + +0:24:01.479,0:24:16.149 +estar aqui, esse primeiro item aqui? qual é o conteúdo do primeiro cara? sim? tão + +0:24:16.149,0:24:21.669 +este aqui vai ser a extensão da minha transformação linear que foi, + +0:24:21.669,0:24:26.169 +você sabe, eu tenho um sinal que é maior do que três amostras, portanto, eu tenho que + +0:24:26.169,0:24:32.229 +tornar esta matriz mais gorda, a segunda parte será dada que eu não me importo + +0:24:32.229,0:24:36.129 +que coisas, tipo, coisas que estão aqui embaixo, não me importo com coisas que estão + +0:24:36.129,0:24:40.299 +aqui, se eu olhar para os pontos que estão aqui em cima, vou colocar um grande 0 aqui + +0:24:40.299,0:24:45.070 +para que tudo que está aqui embaixo seja limpo, né? e + +0:24:45.070,0:24:49.899 +finalmente vou usar o mesmo kernel repetidamente porque + +0:24:49.899,0:24:55.839 +suponho que meus dados estão estacionários e, portanto, suponho que padrões semelhantes + +0:24:55.839,0:24:58.929 +vão acontecer uma e outra vez, portanto, vou usar este + +0:24:58.929,0:25:03.429 +aquele que está escrito aqui: divisão de peso. + +0:25:03.429,0:25:08.019 +Finalmente, dado que este fornece apenas três parâmetros para + +0:25:08.019,0:25:12.940 +trabalhar com vou usar várias camadas para ter diferentes, sabe, + +0:25:12.940,0:25:17.739 +canais. Portanto, este é um kernel. antes, um kernel era toda a linha de + +0:25:17.739,0:25:21.849 +a matriz, ok? então, quando você tem uma camada totalmente conectada, a única diferença + +0:25:21.849,0:25:25.179 +entre uma camada totalmente conectada e uma convolução é que você tem todo o + +0:25:25.179,0:25:37.019 +linha da matriz. Então, o que vai estar neste primeiro item aqui? qualquer um? + +0:25:38.480,0:25:43.230 +então o kernel verde, vamos chamar o kernel verde de apenas 1, deixe-me realmente + +0:25:43.230,0:25:55.200 +faça com que ela brilhe em verde porque é uma semente verde. Então você tem 1 vezes ... o quê? Está + +0:25:55.200,0:25:58.890 +vai ser do número um ao número três certo? e então o segundo item é + +0:25:58.890,0:26:05.640 +vai ser o mesmo cara aqui um 1 e então você vai ter o x mudado por + +0:26:05.640,0:26:20.039 +um e assim por diante certo? faz sentido? sim e então nós teremos este está indo + +0:26:20.039,0:26:23.970 +para ser a saída verde, então você terá a saída azul uma camada chegando + +0:26:23.970,0:26:26.730 +para fora e então você tem o outro vindo o vermelho. + +0:26:26.730,0:26:32.929 +mesmo uma camada de fora. OK? A experiência com o iPad foi legal? + +0:26:32.929,0:26:40.520 +sim? não? Eu gostei. OK. Outras perguntas? + +0:26:41.029,0:26:49.049 +Repita? o círculo azul este aqui? é um grande zero + +0:26:49.049,0:26:53.480 +essa é a dispersão que o mesmo está aqui. + +0:26:53.899,0:26:58.520 +sim? não? Yeah, yeah. + +0:27:01.530,0:27:16.200 +então aqui eu coloquei muitos zeros aqui dentro então matei todos os + +0:27:16.200,0:27:21.000 +valores que estão longe da pequena parte e depois repito os mesmos três + +0:27:21.000,0:27:24.480 +valores repetidamente porque espero encontrar o mesmo padrão em + +0:27:24.480,0:27:33.360 +diferentes regiões deste, este grande grande sinal que eu tenho. Este aqui? Então eu disse + +0:27:33.360,0:27:36.840 +que neste caso terei apenas três valores, certo? e começamos com + +0:27:36.840,0:27:41.040 +12 valores e acabei com 3, que é realmente muito pouco, então se eu quiser + +0:27:41.040,0:27:44.760 +tem, digamos, 6 valores, então se eu quiser ter seis valores e posso ter meu + +0:27:44.760,0:27:49.530 +segundo 3 em um plano diferente e eu realizo a mesma operação sempre que você + +0:27:49.530,0:27:55.110 +multiplique esta matriz por um vetor e você realiza uma convolução para que ela apenas diga + +0:27:55.110,0:27:58.770 +você que uma convolução é apenas uma multiplicação de matriz com muitos zeros + +0:27:58.770,0:28:09.600 +é isso. Sim, então eles vão ter este aqui, então você tem um segundo, + +0:28:09.600,0:28:14.790 +então você tem um terceiro, então você tem três versões da entrada. Tudo bem. Então, para o + +0:28:14.790,0:28:18.000 +segunda parte da aula, vou mostrar a vocês algumas coisas mais interativas + +0:28:18.000,0:28:27.810 +por favor, participe da segunda parte também, certo? então vamos tentar então eu tenho + +0:28:27.810,0:28:37.950 +reformulei a marca Eu mudei a marca do site e agora o + +0:28:37.950,0:28:42.450 +ambiente será chamado de pDL, portanto, o aprendizado profundo PyTorch em vez de + +0:28:42.450,0:28:49.980 +minicurso de aprendizagem profunda, era muito longo. Então, deixe-me começar executando este + +0:28:49.980,0:28:52.460 +tão + +0:28:55.320,0:29:04.960 +Aprendizado profundo do PyTorch para que possamos fazer apenas Conda ativar ativar o PyTorch profundo + +0:29:04.960,0:29:12.940 +aprendizagem (pDL) e a seguir vamos abrir o caderno, o caderno de Júpiter. Tudo bem, então agora você está + +0:29:12.940,0:29:18.520 +vai estar assistindo, repassando a escuta de kernels. Então eu te mostrei um + +0:29:18.520,0:29:22.630 +convolução no papel bem no meu tablet agora você vai ouvir + +0:29:22.630,0:29:25.990 +convolução também pode, de modo que você pode realmente apreciar o que essas convoluções + +0:29:25.990,0:29:35.919 +estão. Aqui dissemos, o novo kernel certo que é chamado pDL PyTorch deep + +0:29:35.919,0:29:42.520 +aprendendo, então você notará o mesmo tipo de procedimento se atualizar + +0:29:42.520,0:29:49.690 +Seu sistema. Tudo bem, então, neste caso, podemos ler o topo aqui, então deixe-me esconder o + +0:29:49.690,0:29:52.200 +topo aqui. + +0:29:52.890,0:29:56.950 +Tudo bem, considerando a suposição de localidade, estacionariedade e + +0:29:56.950,0:30:00.280 +composicionalidade, podemos reduzir a quantidade de computação para uma matriz + +0:30:00.280,0:30:05.169 +multiplicação de vetores usando uma matriz de Toeplitz esparsa porque local porque + +0:30:05.169,0:30:09.850 +esquema estacionário, desta forma, podemos simplesmente acabar redescobrindo o + +0:30:09.850,0:30:14.980 +operador de convolução, certo? além disso, também podemos lembrar que um produto escalar é + +0:30:14.980,0:30:19.150 +uma distância cosseno simplesmente normalizada que nos diz o alinhamento de dois + +0:30:19.150,0:30:21.850 +vetores, mais especificamente, calculamos o + +0:30:21.850,0:30:26.320 +magnitude da projeção ortogonal de dois vetores um sobre o outro e vice + +0:30:26.320,0:30:29.590 +versa. Então, vamos descobrir agora como tudo isso + +0:30:29.590,0:30:34.270 +pode fazer sentido usando nossos ouvidos, certo? então vou importar uma biblioteca que + +0:30:34.270,0:30:39.880 +professor aqui da NYU feito e aqui vou carregar meus dados de áudio e + +0:30:39.880,0:30:43.600 +Eu vou ter isso no meu x, e então minha taxa de amostragem vai ser + +0:30:43.600,0:30:48.570 +na outra variável. Então, aqui vou apenas mostrar que terei cerca de 70.000 + +0:30:48.570,0:30:54.430 +amostras neste caso porque eu tenho uma taxa de amostragem de 22 quilo Hertz e então + +0:30:54.430,0:31:01.720 +meu tempo total será de três segundos, ok, então três segundos vezes 22 você começa + +0:31:01.720,0:31:06.910 +que? então não é 180 que você estava dizendo, era cento e oitenta, era três, certo? + +0:31:06.910,0:31:11.380 +Oh, foram três minutos, você está certo, são três segundos, então você realmente está + +0:31:11.380,0:31:16.540 +corrigir meu mal. Então, são três segundos, então vezes 22 quilo Hertz você tem 70 + +0:31:16.540,0:31:22.390 +cerca de 70.000 amostras. Aqui, vou importar algumas bibliotecas para + +0:31:22.390,0:31:28.180 +mostrarei algo e então mostrarei o primeiro gráfico, então este é + +0:31:28.180,0:31:37.270 +o sinal de áudio que importei agora, como está? ondulado, ok legal. + +0:31:37.270,0:31:50.680 +Você pode me dizer como isso soa? Aluno: "aaaaaaaaaaahhhhhh". Esse foi um bom palpite. O palpite era 'aaah'. Sim, você não pode dizer exatamente + +0:31:50.680,0:31:55.450 +qual é o conteúdo, certo? a partir deste diagrama porque a amplitude de, + +0:31:55.450,0:32:01.240 +o eixo y aqui vai mostrar apenas a amplitude. posso + +0:32:01.240,0:32:05.530 +apague a luz? está tudo bem? ou ... tem certeza? ok obrigado, + +0:32:05.530,0:32:16.090 +Eu realmente não gosto dessas luzes. OK. Boa noite. Oh, vê como isso é bom? Certo + +0:32:16.090,0:32:19.930 +legal. Tudo bem, então você não pode dizer nada aqui, certo? + +0:32:19.930,0:32:26.580 +você não pode dizer o que é o que é o som, certo? então como podemos descobrir + +0:32:26.580,0:32:31.870 +qual é o som aqui dentro? então, por exemplo, posso mostrar a você uma transcrição de + +0:32:31.870,0:32:37.660 +o som e, na verdade, deixe-me realmente forçá-los em seu + +0:32:37.660,0:32:44.810 +sua cabeça, certo? então você vai ter ... espere, não funcionou. * Ouve-se um som * + +0:32:44.810,0:32:50.610 +tudo bem, agora nós realmente ouvimos, ok, agora você pode realmente ver * imita o som * + +0:32:50.610,0:32:56.400 +você sabe que pode imaginar um pouco, mas tudo bem e daí + +0:32:56.400,0:33:00.830 +notas que tocamos lá? como posso descobrir quais são as notas que + +0:33:00.830,0:33:05.550 +eles estão dentro? então vou mostrar este, já que é um pouco mais claro + +0:33:05.550,0:33:13.820 +Eu posso ver seus rostos. Quantos de vocês não podem ler isso? Oh, ai ... + +0:33:13.820,0:33:20.960 +Ok, deixe-me ver se posso pedir ajuda. + +0:33:23.620,0:33:26.620 +Talvez alguém possa nos ajudar aqui. + +0:33:29.400,0:33:32.480 +OK. Vamos ver. + +0:33:40.140,0:33:42.140 +Ei, ei Alf! Oh, oi Alf! + +0:33:42.880,0:33:45.420 +Como está indo? Sim, estou bem, obrigado. + +0:33:45.420,0:33:47.040 +Óculos bonitos lá! Oh, obrigado pelos óculos. + +0:33:47.040,0:33:49.040 +Oh, belo suéter! você também! Belo suéter! + +0:33:49.040,0:33:51.040 +Oh, estamos usando o mesmo suéter! + +0:33:51.040,0:33:54.480 +Você pode nos ajudar? Eles não sabem ler o + +0:33:54.480,0:33:57.120 +Oh, a conexão ... Que diabos! + +0:33:57.120,0:34:00.380 +Eles não podem ler a partitura! Você pode nos ajudar, por favor? + +0:34:00.380,0:34:02.380 +Tudo bem! Deixe-me tentar ajudá-lo. + +0:34:02.380,0:34:04.380 +Obrigado! Deixe-me trocar a câmera. + +0:34:04.380,0:34:06.380 +Tudo bem. Por favor faça. + +0:34:06.380,0:34:08.380 +Então, aqui podemos ir como ... + +0:34:08.380,0:34:10.860 +e ouça primeiro como tudo soa. + +0:34:10.860,0:34:14.320 +Então, vai ser assim. + +0:34:14.440,0:34:23.380 +Quão legal é isso? * alunos aplaudem * + +0:34:23.380,0:34:27.990 +Obrigada. Demorou quatro lições para você me aplaudir. Então agora… + +0:34:27.990,0:34:32.360 +Isso é muito legal da sua parte. Vamos continuar. + +0:34:32.360,0:34:36.320 +A ♭, então temos um E ♭, e então um A ♭. + +0:34:36.320,0:34:40.380 +A diferença entre o primeiro A ♭ e o outro em frequências + +0:34:40.380,0:34:46.540 +é que o primeiro A ♭ terá o dobro da frequência do outro. + +0:34:46.540,0:34:51.400 +E em vez disso, no meio, temos o 5º. Vamos descobrir qual é a frequência disso. + +0:34:51.400,0:34:55.320 +E então, vamos para um B ♭, aqui. + +0:34:55.320,0:34:57.680 +No lado esquerdo, em vez disso, temos o acompanhamento, + +0:34:57.680,0:35:01.220 +e então teremos um A ♭ e B ♭ + +0:35:01.220,0:35:05.620 +e então B ♭ e E ♭. + +0:35:05.680,0:35:10.900 +Então, se juntarmos todos, vamos conseguir este. + +0:35:11.300,0:35:14.020 +Tudo bem? Simples, não? Sim! Obrigado! + +0:35:14.020,0:35:17.320 +Bye Bye! Tchaaaau! + +0:35:18.820,0:35:23.540 +Ver? Demorou um dia inteiro para se preparar ... + +0:35:23.540,0:35:27.480 +Eu estava tão nervoso antes de vir aqui ... + +0:35:27.480,0:35:32.140 +Eu não sabia se realmente teria funcionado ... Ambos, tablet e este. + +0:35:32.140,0:35:35.060 +Estou tão feliz! Agora posso realmente dormir, mais tarde. + +0:35:35.060,0:35:39.280 +De qualquer forma, isso foi como no primeiro + +0:35:39.290,0:35:43.280 +parte você vai ter a primeira nota, há A ♭ que você tem um B ♭ + +0:35:43.280,0:35:51.550 +A ♭ e B ♭ para que você * recrie o som * e oe a diferença entre o primeiro tom e + +0:35:51.550,0:35:57.440 +é uma oitava, portanto a primeira frequência será o dobro da segunda + +0:35:57.440,0:36:02.870 +frequência. OK? então, sempre que vamos observar a forma de onda, um sinal + +0:36:02.870,0:36:07.730 +tem um mais curto igual a metade do período do outro, certo? + +0:36:07.730,0:36:12.410 +especialmente o A ♭ no topo terá um período que é a metade de + +0:36:12.410,0:36:20.000 +o período do A ♭ no inferior, certo, então você * recria o som * ok, se você for a metade de + +0:36:20.000,0:36:27.290 +este que você obteve * soa * certo, ok ok, então, como realmente tiramos essas notas de + +0:36:27.290,0:36:33.770 +esse espectro, da forma de onda? quem pode me dizer como posso extrair estes + +0:36:33.770,0:36:40.790 +arremessos, essas frequências do outro sinal? qualquer palpite? ok transformada de Fourier + +0:36:40.790,0:36:45.530 +que eu acho que é um bom palpite. O que acontece se eu executar agora um + +0:36:45.530,0:36:50.660 +Transformada de Fourier desse sinal? alguém pode realmente me responder? você não pode aumentar + +0:36:50.660,0:36:54.100 +sua mão porque eu não vejo, apenas grite. + +0:36:55.120,0:36:59.690 +Então, se você basicamente realizar a transformada de Fourier de todo o sinal, você + +0:36:59.690,0:37:06.470 +vai ouvir * faz som * como todas as notas juntas * faz som *? todos juntos, certo, mas então você não pode + +0:37:06.470,0:37:13.260 +descobrir qual pitch está tocando, onde ou quando, neste caso, certo. + +0:37:13.260,0:37:18.210 +Ha! Então, precisamos de uma espécie de transformada de Fourier que é localizada e, portanto, um + +0:37:18.210,0:37:23.190 +transformada de Fourier localizada no tempo ou no espaço, dependendo de qualquer domínio + +0:37:23.190,0:37:27.390 +você está usando seu espectrograma denominado. certo, e assim por diante eu vou ser + +0:37:27.390,0:37:30.000 +imprimindo para você o espectrograma, desculpe. + +0:37:30.000,0:37:34.380 +e estarei imprimindo aqui o espectrograma deste aqui. E então aqui + +0:37:34.380,0:37:39.960 +você pode comparar os dois, certo, na primeira parte aqui deste lado aqui você está + +0:37:39.960,0:37:47.970 +vai ter esse pico aqui em 1600 que é o * faz som *, o tom é realmente mais alto. * faz som * lá vamos nós. Agora + +0:37:47.970,0:37:56.640 +você tem um segundo que é este pico aqui * faz som * e então este * faz som *. Você pode ver esse pico, certo? E você + +0:37:56.640,0:38:04.260 +veja este pico, tudo bem, então esses picos serão as notas reais que toco + +0:38:04.260,0:38:07.560 +com a mão direita, então vamos colocá-los juntos e + +0:38:07.560,0:38:13.140 +Vou ter aqui as frequências. Então eu tenho 1600, 1200 e 800, você pode ver aqui? + +0:38:13.140,0:38:20.550 +Eu tenho 1600, 800, por que um é o dobro do outro? porque eles são uma oitava + +0:38:20.550,0:38:27.540 +separados, então se isso é * faz som * isso vai ser * faz som * certo e este é um quinto que também + +0:38:27.540,0:38:32.280 +tem um bom intervalo. Então, deixe-me gerar esses sinais aqui e depois + +0:38:32.280,0:38:36.720 +tem que ser concatená-los todos, então vou jogar os dois. o primeiro + +0:38:36.720,0:38:42.109 +um é na verdade o áudio original, mas + +0:38:42.109,0:38:45.470 +deixe-me tentar de novo, enquanto se eu jogar + +0:38:45.680,0:38:54.860 +o segundo, a concatenação, sim, está um pouco alto, agora não consigo nem + +0:38:54.860,0:39:01.720 +reduza o volume. Oh, eu posso reduzir isso aqui. Demais. Ok, deixe-me ir de novo. Tudo + +0:39:02.020,0:39:05.350 +direito. Então, esta é a concatenação desses + +0:39:05.350,0:39:12.380 +quatro pitches diferentes, então adivinhe o que faremos a seguir? então como posso + +0:39:12.380,0:39:20.420 +extrair todas as notas que posso ouvir em uma peça específica? então vamos dizer + +0:39:20.420,0:39:29.360 +você joga uma partitura completa e eu gostaria de saber qual campo é jogado e a que horas. Do + +0:39:29.360,0:39:36.230 +que? então a resposta foi convolução, apenas para a gravação, então estou pedindo convolução + +0:39:36.230,0:39:43.370 +sobre o que? sem convolução do espectrograma, então você tem convolução de sua entrada + +0:39:43.370,0:39:49.460 +sinalizar com o quê? com algum tipo diferente de pitches, os quais irão + +0:39:49.460,0:39:59.150 +sua vez? digamos que você não veja o espectro, porque digamos que eu só vou + +0:39:59.150,0:40:03.770 +tocar qualquer tipo de música, então eu gostaria de saber todas as notas possíveis que são + +0:40:03.770,0:40:06.220 +aí o que você faria? + +0:40:06.220,0:40:13.430 +você não conhece todos os arremessos, como você tentaria? certo, então em que estão todos os + +0:40:13.430,0:40:20.900 +tons que você pode querer usar, se estiver tocando piano? todas as chaves de + +0:40:20.900,0:40:24.530 +o piano, certo? então, se eu tocar um concerto com o piano, eu quero + +0:40:24.530,0:40:28.010 +tenho um pedaço de áudio para cada uma dessas teclas e vou estar executando + +0:40:28.010,0:40:32.690 +circunvoluções de toda a minha peça com as chaves antigas, certo? e portanto você é + +0:40:32.690,0:40:36.470 +veremos picos que são o alinhamento da similaridade do cosseno + +0:40:36.470,0:40:41.349 +sempre que você obtiver basicamente o áudio correspondente ao seu kernel específico. + +0:40:41.349,0:40:46.989 +então vou fazer isso, mas com esses tons específicos, na verdade, extraio + +0:40:46.989,0:40:52.929 +aqui. Então, aqui vou mostrar primeiro como os dois espectrogramas se parecem + +0:40:52.929,0:40:57.699 +como se o lado esquerdo fosse o espectrograma do meu sinal real X de t + +0:40:57.699,0:41:01.630 +e no lado direito eu tenho apenas o espectrograma desta concatenação de + +0:41:01.630,0:41:10.749 +meus argumentos, então aqui você pode ver claramente que isso * faz som *, mas aqui, em primeiro lugar, o que + +0:41:10.749,0:41:14.429 +são essas barras aqui, essas barras verticais? + +0:41:15.269,0:41:20.589 +você está seguindo, certo? Eu não posso te ver, tenho que realmente responder. O que são esses vermelhos + +0:41:20.589,0:41:24.160 +barras aqui, barras verticais? Agora, o horizontal eu já falei pra vocês, né? + +0:41:24.160,0:41:34.390 +* faz som * e a vertical? o que é? problemas de amostragem, certo, transições. Então + +0:41:34.390,0:41:39.099 +sempre que você tem o * faz som *, você na verdade tem uma forma de onda branca, uma forma de onda e depois + +0:41:39.099,0:41:44.019 +o outro, uma forma de onda tem que parar para que não seja mais periódica e sempre + +0:41:44.019,0:41:47.609 +você faz uma transformada de Fourier de um sinal não periódico, você sabe uma porcaria. + +0:41:47.609,0:41:53.589 +É por isso que sempre que você consegue a junção entre eles o * faz o som * o salto + +0:41:53.589,0:41:57.729 +aqui você vai ter este pico porque você pode + +0:41:57.729,0:42:01.749 +pensar no salto é como ter uma frequência muito alta né? Porque + +0:42:01.749,0:42:05.469 +é como um delta, então você realmente consegue todas as frequências, é por isso que você + +0:42:05.469,0:42:12.549 +obtenha todas as frequências aqui. Estrondo. OK? faz sentido até agora? tipo de? tudo bem. + +0:42:12.549,0:42:18.720 +Esta é a versão limpa * faz som * Não consigo nem assinar e o que + +0:42:18.720,0:42:25.800 +lado esquerdo aqui? por que está do lado esquerdo todo vermelho aí embaixo? OK + +0:42:25.800,0:42:31.440 +sim, você sabia. então o lado esquerdo do lado esquerdo do cabo é o que eu mostro a vocês no + +0:42:31.440,0:42:37.320 +lado esquerdo inferior. Ok, então deixe-me terminar esta aula e depois deixo você ir. Então + +0:42:37.320,0:42:42.990 +aqui vou te mostrar primeiro todos os kernels, você pode dizer agora + +0:42:42.990,0:42:48.090 +o vermelho vai ser o primeiro pedaço do meu sinal, o real + +0:42:48.090,0:42:53.280 +um e então você pode ver que o primeiro tom tem a mesma frequência, + +0:42:53.280,0:42:58.460 +você pode ver? Portanto, o * faz som * tem o mesmo + +0:42:58.460,0:43:04.230 +delta t o mesmo intervalo, período, você pode ver? você não pode acenar com a cabeça + +0:43:04.230,0:43:08.700 +cabeça porque de novo eu não vejo você, tem que me responder. Você pode ver ou não? OK, + +0:43:08.700,0:43:13.050 +obrigado, fantástico. E então este é o terceiro, você pode ver que + +0:43:13.050,0:43:17.130 +começa aqui no período e termina aqui, se você subir aqui você está + +0:43:17.130,0:43:20.520 +veremos exatamente que havia dois desses caras, certo, então isso é + +0:43:20.520,0:43:24.619 +como você pode ver isso é como o dobro da frequência do abaixo. + +0:43:24.619,0:43:30.089 +Finalmente, irei realizar a convolução desses quatro kernels com + +0:43:30.089,0:43:36.839 +meu sinal de entrada, e é assim que parecemos, ok, então o primeiro kernel tem um alto + +0:43:36.839,0:43:42.150 +coincidir na primeira parte do placar. Então, entre zero e zero cinco + +0:43:42.150,0:43:46.830 +segundos. O segundo começa logo após o primeiro, então você tem o + +0:43:46.830,0:43:50.820 +terceiro começando em zero três eu acho e então você tem o último + +0:43:50.820,0:43:56.940 +começando do zero seis, certo? Então adivinhe? Eu vou fazer você ouvir + +0:43:56.940,0:44:02.520 +convoluções agora, você está animado? ok, você realmente está respondendo agora, ótimo! + +0:44:02.520,0:44:07.440 +Tudo bem e esses são os resultados. Deixe-me baixar um pouco os volumes + +0:44:07.440,0:44:14.900 +caso contrário, você reclamará, sim, eu não posso diminuir o, + +0:44:16.800,0:44:23.690 +ok, então o primeiro, vamos tentar novamente + +0:44:28.880,0:44:37.110 +* toca som * não é legal? Você escuta as convoluções. Ok, então basicamente isso era + +0:44:37.110,0:44:41.280 +quase isso, tenho mais um slide porque senti que houve alguma confusão no último + +0:44:41.280,0:44:45.360 +tempo sobre qual é a diferente dimensionalidade de diferentes tipos de + +0:44:45.360,0:44:50.850 +sinais, então estou realmente recomendando ir e fazer a aula da Joan Bruna que + +0:44:50.850,0:44:56.580 +é matemática para aprendizado profundo e eu roubei uma das pequenas coisas que ele era + +0:44:56.580,0:45:04.320 +ensinando, acabei de colocar um slide aqui para você. Portanto, este slide é o + +0:45:04.320,0:45:13.140 +Segue. Portanto, temos a camada de entrada ou as amostras que fornecemos em + +0:45:13.140,0:45:18.420 +esta rede e então normalmente nossa última vez eu defino isso eu tenho este X encaracolado + +0:45:18.420,0:45:23.010 +que será feito daqueles xi, que são todas as minhas amostras de dados corretas + +0:45:23.010,0:45:29.100 +e geralmente tenho m amostras de dados, então meu i vai de m = 1 para n, ok, então + +0:45:29.100,0:45:34.080 +está claro? em que esta notação está clara? porque é um pouco mais formal, normalmente sou um pouco + +0:45:34.080,0:45:39.030 +menos formal, mas, de alguma forma, alguém estava se sentindo um pouco desconfortável. + +0:45:39.030,0:45:46.470 +acho que este é apenas meus exemplos de entrada, mas também podemos ver este + +0:45:46.470,0:45:52.950 +é este X encaracolado que é minha entrada definida como o conjunto de todas essas funções como xi + +0:45:52.950,0:45:59.850 +que estão mapeando meu Omega capital Omega, que é meu domínio, para um RC que é + +0:45:59.850,0:46:06.150 +serão basicamente meus canais desse exemplo específico e aqui estou + +0:46:06.150,0:46:14.040 +mapearei aqueles Omega minúsculos para esses xi's de ômega, então vamos ver como + +0:46:14.040,0:46:17.550 +estes são diferentes da notação anterior. Então eu vou te dar agora três + +0:46:17.550,0:46:21.300 +exemplos e você deve ser capaz de dizer agora qual é a dimensionalidade e + +0:46:21.300,0:46:24.820 +neste exemplo. Então, o primeiro, digamos, + +0:46:24.820,0:46:29.560 +Eu gostei do que mostrei a você agora, apenas uma parte divertida de você + +0:46:29.560,0:46:34.870 +sinal de áudio, então meu Omega será apenas amostras como a amostra número um + +0:46:34.870,0:46:39.550 +amostra número dois como o índice, certo? então você tem índice um, índice dois, índice + +0:46:39.550,0:46:44.740 +até esses 70.000 seja o que for que acabamos de ver agora, ok? e o último valor é + +0:46:44.740,0:46:49.330 +vai ser o T, T maiúsculo, que é o número de segundos dividido pelo delta T + +0:46:49.330,0:46:53.200 +que seria o 1 sobre a frequência e isso vai ser um + +0:46:53.200,0:46:57.250 +subconjunto de n certo? então este é um número discreto de amostras, porque você tem um + +0:46:57.250,0:47:03.220 +computador, você sempre tem amostras discretas. Portanto, estes são meus dados de entrada, e + +0:47:03.220,0:47:09.310 +então que tal a imagem desta função? então quando eu pergunto o que é + +0:47:09.310,0:47:13.330 +dimensionalidade deste tipo de sinal, você deve responder que é um + +0:47:13.330,0:47:19.360 +sinal unidimensional porque a potência desses n aqui é 1 ok? então isso é como + +0:47:19.360,0:47:25.000 +um sinal unidimensional, embora você possa ter o tempo total e o + +0:47:25.000,0:47:28.900 +1 lá estava um intervalo de amostragem, do lado direito você tem o número + +0:47:28.900,0:47:33.340 +de canais pode ser 1 se você tiver um sinal mono ou 2 se tiver um + +0:47:33.340,0:47:38.230 +estereofônico, então você tem mono aí, você tem 2 para estereofônico ou o que é 5 + +0:47:38.230,0:47:44.650 +mais 1? esse é o Dolby como 5.1 não é legal? tudo bem então este ainda é um + +0:47:44.650,0:47:48.430 +sinal dimensional que pode ter vários canais, mas ainda é + +0:47:48.430,0:47:53.020 +sinal unidimensional porque há apenas uma variável em execução lá, ok? é isso + +0:47:53.020,0:47:58.270 +de alguma forma melhor do que da última vez? sim? não? Melhor? obrigada. + +0:47:58.270,0:48:03.070 +vamos agradecer a Joan. Tudo bem, segundo exemplo que tenho aqui, meu Omega vai + +0:48:03.070,0:48:07.630 +ser o produto cartesiano desses dois conjuntos, o primeiro conjunto vai + +0:48:07.630,0:48:13.150 +de 1 em altura, e também esta discreta e a outra vai + +0:48:13.150,0:48:17.020 +indo de 1 para a largura, então estes são os pixels reais, e este + +0:48:17.020,0:48:21.690 +é um sinal bidimensional porque tenho 2 graus de liberdade no meu + +0:48:21.690,0:48:28.690 +domínio. Quais são os canais possíveis que temos? Então, aqui, os canais possíveis que + +0:48:28.690,0:48:32.440 +são muito comuns são os seguintes: Assim, você pode ter uma imagem em tons de cinza e + +0:48:32.440,0:48:36.849 +portanto, você apenas produz um valor escalar ou obtém o + +0:48:36.849,0:48:42.789 +arco-íris ali, a cor e, portanto, você fica como o meu X que é uma função de + +0:48:42.789,0:48:49.299 +as coordenadas Omega 1 Omega 2 em que cada ponto é + +0:48:49.299,0:48:52.690 +representado por um vetor de três componentes que será o R + +0:48:52.690,0:48:59.109 +componente do ponto Omega 1 Omega 2, o componente G do Omega 1 Omega 2, e + +0:48:59.109,0:49:04.299 +o componente azul do Omega 1 Omega 2. Então, novamente, vocês podem pensar nisso como um + +0:49:04.299,0:49:08.980 +ponto de big big data ou você pode pensar nisso como um mapeamento de função + +0:49:08.980,0:49:12.640 +domínio dimensional que é um domínio bidimensional para um domínio tridimensional + +0:49:12.640,0:49:18.490 +domínio dimensional, certo? finalmente os vinte, quem sabe o nome do + +0:49:18.490,0:49:24.400 +imagem de vinte canais? sim, esta é uma imagem hiperespectral. É muito comum + +0:49:24.400,0:49:31.869 +tem 20 bandas. Finalmente, quem pode adivinhar este? + +0:49:31.869,0:49:40.829 +se meu domínio for r4 x r4, o que pode ser? + +0:49:41.099,0:49:50.589 +Não, não, isso discreto né? Este é o r4, então nem é computador. Ha! + +0:49:50.589,0:49:56.740 +quem disse algo ai? Ouvi! Sim, está correto, então este é o espaço-tempo, o que + +0:49:56.740,0:50:00.849 +é o segundo? Sim, qual impulso? Tem um especial + +0:50:00.849,0:50:07.779 +nome. É chamado de quatro momentos porque tem uma informação temporal como + +0:50:07.779,0:50:12.160 +bem, certo? E então qual será a minha possível imagem + +0:50:12.160,0:50:24.790 +da função X? digamos que c é igual a 1. O que é? você sabe? + +0:50:24.790,0:50:29.630 +Então esse poderia ser, por exemplo, o hamiltoniano do sistema, certo? então, é isso + +0:50:29.630,0:50:36.460 +foi como um pouco mais de introdução matemática ou matemática + +0:50:37.000,0:50:42.890 +procedimento, como se diz, você fará uma definição mais precisa. De modo a + +0:50:42.890,0:50:48.980 +foi praticamente tudo por hoje, deixa eu acender a luz e vejo você + +0:50:48.980,0:50:54.969 +na próxima segunda-feira. Obrigado por estar comigo. \ No newline at end of file diff --git a/docs/pt/week05/05-1.md b/docs/pt/week05/05-1.md new file mode 100644 index 000000000..92eae3fca --- /dev/null +++ b/docs/pt/week05/05-1.md @@ -0,0 +1,451 @@ +--- +lang: pt +lang-ref: ch.05-1 +title: Técnicas de Otimização I +lecturer: Aaron Defazio +authors: Vaibhav Gupta, Himani Shah, Gowri Addepalli, Lakshmi Addepalli +date: 24 Feb 2020 +translation-date: 06 Nov 2021 +translator: Felipe Schiavon +--- + + + + +## [Gradiente Descendente](https://www.youtube.com/watch?v=--NZb480zlg&t=88s) + + + +Começamos nosso estudo de Métodos de Otimização com o pior e mais básico método (raciocínio a seguir) do lote, o Gradiente Descendente. + + + +**Problema:** + + + +$$ +\min_w f(w) +$$ + + + +**Solução Iterativa:** + + + +$$ +w_{k+1} = w_k - \gamma_k \nabla f(w_k) +$$ + + + +onde, + - $w_{k+1}$ é o valor atualizado depois da $k$-ésima iteração, + - $w_k$ é o valor inicial antes da $k$-ésima iteração, + - $\gamma_k$ é o tamanho do passo, + - $\nabla f(w_k)$ é o gradiente de $f$. + + + +A suposição aqui é que a função $f$ é contínua e diferenciável. Nosso objetivo é encontrar o ponto mais baixo (vale) da função de otimização. No entanto, a direção real para este vale não é conhecida. Só podemos olhar localmente e, portanto, a direção do gradiente negativo é a melhor informação que temos. Dar um pequeno passo nessa direção só pode nos levar mais perto do mínimo. Assim que tivermos dado o pequeno passo, calculamos novamente o novo gradiente e novamente nos movemos um pouco nessa direção, até chegarmos ao vale. Portanto, basicamente tudo o que o gradiente descendente está fazendo é seguir a direção da descida mais acentuada (gradiente negativo). + + + +O parâmetro $\gamma$ na equação de atualização iterativa é chamado de **tamanho do passo**. Geralmente não sabemos o valor do tamanho ideal do passo; então temos que tentar valores diferentes. A prática padrão é tentar vários valores em uma escala logarítmica e, a seguir, usar o melhor valor. Existem alguns cenários diferentes que podem ocorrer. A imagem acima descreve esses cenários para uma função de erro quadrática de uma dimensão (1D). Se a taxa de aprendizado for muito baixa, faremos um progresso constante em direção ao mínimo. No entanto, isso pode levar mais tempo do que o ideal. Geralmente é muito difícil (ou impossível) obter um tamanho de passo que nos leve diretamente ao mínimo. O que desejaríamos idealmente é ter um tamanho de degrau um pouco maior do que o ideal. Na prática, isso dá a convergência mais rápida. No entanto, se usarmos uma taxa de aprendizado muito grande, as iterações se distanciam cada vez mais dos mínimos e obtemos divergência. Na prática, gostaríamos de usar uma taxa de aprendizado um pouco menor do que divergente. + + + +
+
+Figure 1: Tamanhos dos passos para função de erro quadrática de uma dimensão (1D) +
+ + + + +## [Gradiente Descendente Estocástico](https://www.youtube.com/watch?v=--NZb480zlg&t=898s) + + + +No Gradiente Descendente Estocástico, substituímos o vetor gradiente real por uma estimativa estocástica do vetor gradiente. Especificamente para uma rede neural, a estimativa estocástica significa o gradiente da perda para um único ponto dos dados (única instância). + + + +Seja $f_i$ a perda da rede para a $i$-ésima instância. + + + +$$ +f_i = l(x_i, y_i, w) +$$ + + + +A função que queremos minimizar é $f$, a perda total de todas as instâncias. + + + +$$ +f = \frac{1}{n}\sum_i^n f_i +$$ + + + + +No SGD, atualizamos os pesos de acordo com o gradiente sobre $f_i$ (em oposição ao gradiente sobre a perda total $f$). + + + +$$ +\begin{aligned} +w_{k+1} &= w_k - \gamma_k \nabla f_i(w_k) & \quad\text{(i escolhido uniformemente ao acaso)} +\end{aligned} +$$ + + + +Se $i$ for escolhido aleatoriamente, então $f_i$ é um estimador com ruído, mas sem viés, de $f$, que é matematicamente escrito como: + + + +$$ +\mathbb{E}[\nabla f_i(w_k)] = \nabla f(w_k) +$$ + + + +Como resultado disso, a $k$-ésima etapa esperada do SGD é a mesma que a $k$-ésima etapa da Gradiente Descendente completo: + + + +$$ +\mathbb{E}[w_{k+1}] = w_k - \gamma_k \mathbb{E}[\nabla f_i(w_k)] = w_k - \gamma_k \nabla f(w_k) +$$ + + + +Portanto, qualquer atualização do SGD é igual à atualização de lote completo em expectativa. No entanto, o SGD não é apenas um gradiente descendente mais rápida com algum ruído. Além de ser mais rápido, o SGD também pode nos dar melhores resultados do que o gradiente descendente completo. O ruído no SGD pode nos ajudar a evitar os mínimos locais superficiais e a encontrar mínimos melhores (mais profundos). Este fenômeno é denominado **recozimento** (**annealing**). + + + +
+
+Figure 2: Recozimento com SGD +
+ + + +Em resumo, as vantagens do Gradiente Descendente Estocástico são as seguintes: + + + +1. Há muitas informações redundantes entre as instâncias. O SGD evita muitos desses cálculos redundantes. + 2. Nos estágios iniciais, o ruído é pequeno em comparação com as informações no gradiente. Portanto, uma etapa SGD é *virtualmente tão boa quanto* uma etapa de Gradiente Descendente. + 3. *Recozimento* - O ruído na atualização do SGD pode impedir a convergência para mínimos locais ruins (rasos). + 4. O Gradiente Descendente Estocástico é drasticamente mais barato para calcular (já que você não passa por todos os pontos de dados). + + + + +### Mini-lotes + + + +Em mini-lotes, consideramos a perda em várias instâncias selecionadas aleatoriamente em vez de calculá-la em apenas uma instância. Isso reduz o ruído em cada etapa da atualização do passo. + + + +$$ +w_{k+1} = w_k - \gamma_k \frac{1}{|B_i|} \sum_{j \in B_i}\nabla f_j(w_k) +$$ + + + +Freqüentemente, podemos fazer melhor uso de nosso hardware usando mini-lotes em vez de uma única instância. Por exemplo, as GPUs são mal utilizadas quando usamos o treinamento de instância única. As técnicas de treinamento de rede distribuída dividem um grande mini-lote entre as máquinas de um cluster e, em seguida, agregam os gradientes resultantes. O Facebook treinou recentemente uma rede em dados ImageNet em uma hora, usando treinamento distribuído. + + + +É importante observar que o Gradiente Descendente nunca deve ser usado com lotes de tamanho normal. Caso você queira treinar no tamanho total do lote, use uma técnica de otimização chamada LBFGS. O PyTorch e o SciPy possuem implementações desta técnica. + + + +## [Momento](https://www.youtube.com/watch?v=--NZb480zlg&t=1672s) + + + +No Momento, temos duas iterações ($p$ e $w$) ao invés de apenas uma. As atualizações são as seguintes: + + + +$$ +\begin{aligned} +p_{k+1} &= \hat{\beta_k}p_k + \nabla f_i(w_k) \\ +w_{k+1} &= w_k - \gamma_kp_{k+1} \\ +\end{aligned} +$$ + + + +$p$ é chamado de momento SGD. Em cada etapa de atualização do passo, adicionamos o gradiente estocástico ao antigo valor do momento, após amortecê-lo por um fator $\beta$ (valor entre 0 e 1). $p$ pode ser considerado uma média contínua dos gradientes. Finalmente, movemos $w$ na direção do novo momento $p$. + + + +Forma alternativa: Método Estocástico de Bola Pesada + + + +$$ +\begin{aligned} +w_{k+1} &= w_k - \gamma_k\nabla f_i(w_k) + \beta_k(w_k - w_{k-1}) & 0 \leq \beta < 1 +\end{aligned} +$$ + + + +Esta forma é matematicamente equivalente à forma anterior. Aqui, o próximo passo é uma combinação da direção do passo anterior ($w_k - w_{k-1}$) e o novo gradiente negativo. + + + +### Intuição + + + +O Momento do SGD é semelhante ao conceito de momentum na física. O processo de otimização se assemelha a uma bola pesada rolando colina abaixo. O momento mantém a bola se movendo na mesma direção em que já está se movendo. O gradiente pode ser considerado como uma força que empurra a bola em alguma outra direção. + + + +
+
+Figure 3: Efeito do Momento
+Source: distill.pub
+
+ + + + +Ao invés de fazer mudanças dramáticas na direção do caminho (como na figura à esquerda), o momento faz mudanças pequenas. O momento amortece as oscilações que são comuns quando usamos apenas SGD. + + + +O parâmetro $\beta$ é chamado de fator de amortecimento. $\beta$ tem que ser maior que zero, porque se for igual a zero, você está apenas fazendo um gradiente descendente comum. Também deve ser menor que 1, caso contrário, tudo explodirá. Valores menores de $\beta$ resultam em mudanças de direção mais rápidas. Para valores maiores, leva mais tempo para fazer curvas. + + + +
+
+Figure 4: Efeito do Beta na Convergência +
+ + + + +### Diretrizes práticas + + + +O momento deve quase sempre ser usado com o Gradiente Descendente Estocástico. +$\beta$ = 0,9 ou 0,99 quase sempre funciona bem. + + + +O parâmetro de tamanho do passo geralmente precisa ser reduzido quando o parâmetro de momento é aumentado para manter a convergência. Se $\beta$ mudar de 0,9 para 0,99, a taxa de aprendizagem deve ser reduzida em um fator de 10. + + + + +### Por que o momento funciona? + + + + +#### Aceleração + + + + +A seguir estão as regras de atualização para o Momento de Nesterov. + + + +$$ +p_{k+1} = \hat{\beta_k}p_k + \nabla f_i(w_k) \\ +w_{k+1} = w_k - \gamma_k(\nabla f_i(w_k) +\hat{\beta_k}p_{k+1}) +$$ + + + +Com o Momento de Nesterov, você pode obter uma convergência acelerada se escolher as constantes com cuidado. Mas isso se aplica apenas a problemas convexos e não a redes neurais. + + + +Muitas pessoas dizem que o momento normal também é um método acelerado. Mas, na realidade, ele é acelerado apenas para funções quadráticas. Além disso, a aceleração não funciona bem com SGD, pois SGD tem ruído e a aceleração não funciona bem com ruído. Portanto, embora um pouco de aceleração esteja presente no SGD com Momento, por si só não é uma boa explicação para o alto desempenho da técnica. + + + + +#### Suavização de ruído + + + +Provavelmente, uma razão mais prática e provável de por que o momento funciona é a Suavização de ruído. + + + + +O momento calcula a média dos gradientes. É uma média contínua de gradientes que usamos para cada atualização do passo. + + + +Teoricamente, para que o SGD funcione, devemos obter a média de todas as atualizações dos passos. + + + +$$ +\bar w_k = \frac{1}{K} \sum_{k=1}^K w_k +$$ + + + +A grande vantagem do SGD com momento é que essa média não é mais necessária. O Momento adiciona suavização ao processo de otimização, o que torna cada atualização uma boa aproximação da solução. Com o SGD, você desejaria calcular a média de um monte de atualizações e, em seguida, dar um passo nessa direção. + + + +Tanto a aceleração quanto a suavização de ruído contribuem para um alto desempenho do Momento. + + + +
+
+Figure 5: SGD vs. Momento +
+ + + +Com o Gradiente Descendente Estocástico, inicialmente, fazemos um bom progresso em direção à solução, mas quando alcançamos o fundo da "tigela", ficamos rodeando em volta deste piso. Se ajustarmos a taxa de aprendizado, vamos rodear mais devagar. Com o impulso, suavizamos os degraus, para que não haja saltos. diff --git a/docs/pt/week05/05-2.md b/docs/pt/week05/05-2.md new file mode 100644 index 000000000..6c925fb0f --- /dev/null +++ b/docs/pt/week05/05-2.md @@ -0,0 +1,512 @@ +--- +lang: pt +lang-ref: ch.05-2 +title: Técnicas de Otimização II +lecturer: Aaron Defazio +authors: Guido Petri, Haoyue Ping, Chinmay Singhal, Divya Juneja +date: 24 Feb 2020 +translator: Felipe Schiavon +translation-date: 14 Nov 2021 +--- + + + + +## [Métodos Adaptativos](https://www.youtube.com/watch?v=--NZb480zlg&t=2675s) + + + +Momento com SGD é atualmente o método de otimização de última geração para muitos problemas de aprendizagem de máquina. Mas existem outros métodos, geralmente chamados de Métodos Adaptativos, inovados ao longo dos anos que são particularmente úteis para problemas mal condicionados (se o SGD não funcionar). + + + +Na formulação SGD, cada peso na rede é atualizado usando uma equação com a mesma taxa de aprendizado (global $\gamma$). Aqui, para métodos adaptativos, *adaptamos uma taxa de aprendizagem para cada peso individualmente*. Para tanto, são utilizadas as informações que obtemos dos gradientes para cada peso. + + + +As redes que são frequentemente usadas na prática têm estruturas diferentes em diferentes partes delas. Por exemplo, partes iniciais da CNN podem ser camadas de convolução muito rasas em imagens grandes e, posteriormente, na rede, podemos ter convoluções de grande número de canais em imagens pequenas. Ambas as operações são muito diferentes, portanto, uma taxa de aprendizado que funciona bem para o início da rede pode não funcionar bem para as últimas seções da rede. Isso significa que as taxas de aprendizagem adaptativa por camada podem ser úteis. + + + +Os pesos na última parte da rede (4096 na figura 1 abaixo) ditam diretamente a saída e têm um efeito muito forte sobre ela. Portanto, precisamos de taxas de aprendizado menores para eles. Em contraste, pesos anteriores terão efeitos individuais menores na saída, especialmente quando inicializados aleatoriamente. + + + +
+
+Figure 1: VGG16 +
+ + + + +### RMSprop + + + +A ideia principal da *Propagação da raiz do valor quadrático médio* (*Root Mean Square Propagation*) é que o gradiente é normalizado por sua raiz quadrada média. + + + +Na equação abaixo, elevar ao quadrado o gradiente denota que cada elemento do vetor é elevado ao quadrado individualmente. + + + +$$ +\begin{aligned} +v_{t+1} &= {\alpha}v_t + (1 - \alpha) \nabla f_i(w_t)^2 \\ +w_{t+1} &= w_t - \gamma \frac {\nabla f_i(w_t)}{ \sqrt{v_{t+1}} + \epsilon} +\end{aligned} +$$ + + + +onde $\gamma$ é a taxa de aprendizagem global, $\epsilon$ é um valor próximo a máquina $\epsilon$ (na ordem de $10^{-7}$ ou $10^{-8}$) - na ordem para evitar erros de divisão por zero, e $v_{t+1}$ é a estimativa do segundo momento. + + + +Atualizamos $v$ para estimar essa quantidade ruidosa por meio de uma *média móvel exponencial* (que é uma maneira padrão de manter uma média de uma quantidade que pode mudar com o tempo). Precisamos colocar pesos maiores nos valores mais novos, pois eles fornecem mais informações. Uma maneira de fazer isso é reduzir exponencialmente os valores antigos. Os valores no cálculo de $v$ que são muito antigos são reduzidos a cada etapa por uma constante $\alpha$, que varia entre 0 e 1. Isso amortece os valores antigos até que eles não sejam mais uma parte importante do exponencial média móvel. + + + +O método original mantém uma média móvel exponencial de um segundo momento não central, portanto, não subtraímos a média aqui. O *segundo momento* é usado para normalizar o gradiente em termos de elemento, o que significa que cada elemento do gradiente é dividido pela raiz quadrada da estimativa do segundo momento. Se o valor esperado do gradiente for pequeno, esse processo é semelhante a dividir o gradiente pelo desvio padrão. + + + +Usar um $\epsilon$ pequeno no denominador não diverge porque quando $v$ é muito pequeno, o momento também é muito pequeno. + + + + +### ADAM + + + +ADAM, ou *Estimativa Adaptativa do Momento*, que é RMSprop mais o Momento, é o método mais comumente usado. A atualização do Momento é convertida em uma média móvel exponencial e não precisamos alterar a taxa de aprendizagem quando lidamos com $\beta$. Assim como no RMSprop, pegamos uma média móvel exponencial do gradiente quadrado aqui. + + + +$$ +\begin{aligned} +m_{t+1} &= {\beta}m_t + (1 - \beta) \nabla f_i(w_t) \\ +v_{t+1} &= {\alpha}v_t + (1 - \alpha) \nabla f_i(w_t)^2 \\ +w_{t+1} &= w_t - \gamma \frac {m_{t}}{ \sqrt{v_{t+1}} + \epsilon} +\end{aligned} +$$ + + + +onde $m_{t+1}$ é a média móvel exponencial do momento. + + + +A correção de viés que é usada para manter a média móvel imparcial durante as iterações iniciais não é mostrada aqui. + + + + +### Lado Prático + + + +Ao treinar redes neurais, o SGD geralmente vai na direção errada no início do processo de treinamento, enquanto o RMSprop aprimora a direção certa. No entanto, o RMSprop sofre de ruído da mesma forma que o SGD normal, então ele oscila em torno do ótimo significativamente quando está perto de um minimizador local. Assim como quando adicionamos impulso ao SGD, obtemos o mesmo tipo de melhoria com o ADAM. É uma estimativa boa e não ruidosa da solução, portanto **ADAM é geralmente recomendado em vez de RMSprop**. + + + +
+
+Figure 2: SGD *vs.* RMSprop *vs.* ADAM +

+ + + +O ADAM é necessário para treinar algumas das redes para usar modelos de linguagem. Para otimizar redes neurais, SGD com momentum ou ADAM é geralmente preferido. No entanto, a teoria do ADAM em artigos é mal compreendida e também tem várias desvantagens: + + + +* Pode ser mostrado em problemas de teste muito simples que o método não converge. +* É conhecido por fornecer erros de generalização. Se a rede neural for treinada para fornecer perda zero nos dados em que você a treinou, ela não fornecerá perda zero em outros pontos de dados que nunca viu antes. É bastante comum, principalmente em problemas de imagem, obtermos erros de generalização piores do que quando se usa SGD. Os fatores podem incluir que ele encontre o mínimo local mais próximo, ou menos ruído no ADAM, ou sua estrutura, por exemplo. +* Com o ADAM, precisamos manter 3 buffers, enquanto o SGD precisa de 2 buffers. Isso realmente não importa, a menos que treinemos um modelo da ordem de vários gigabytes de tamanho; nesse caso, ele pode não caber na memória. +* 2 parâmetros de momentum precisam ser ajustados em vez de 1. + + + + +## [Camadas de Normalização](https://www.youtube.com/watch?v=--NZb480zlg&t=3907s) + + + +Em vez de melhorar os algoritmos de otimização, as *camadas de normalização* melhoram a própria estrutura da rede. Eles são camadas adicionais entre as camadas existentes. O objetivo é melhorar o desempenho de otimização e generalização. + + + +Em redes neurais, normalmente alternamos operações lineares com operações não lineares. As operações não lineares também são conhecidas como funções de ativação, como ReLU. Podemos colocar camadas de normalização antes das camadas lineares ou após as funções de ativação. A prática mais comum é colocá-los entre as camadas lineares e as funções de ativação, como na figura abaixo. + + + +|
|
|
| +| (a) Antes de adicionar a normalização | (b) Depois de adicionar a normalização | (c) Um exemplo em CNNs | + + + +
Figura 3: Posições típicas de camadas de normalização.
+ + + +Na figura 3 (c), a convolução é a camada linear, seguida pela normalização do lote, seguida por ReLU. + + + +Observe que as camadas de normalização afetam os dados que fluem, mas não alteram o poder da rede no sentido de que, com a configuração adequada dos pesos, a rede não normalizada ainda pode dar a mesma saída que uma rede normalizada. + + + + +### Operações de normalização + + + +Esta é a notação genérica para normalização: + + + +$$ +y = \frac{a}{\sigma}(x - \mu) + b +$$ + + + +onde $x$ é o vetor de entrada, $y$ é o vetor de saída, $\mu$ é a estimativa da média de $x$, $\sigma$ é a estimativa do desvio padrão (std) de $x$ , $a$ é o fator de escala que pode ser aprendido e $b$ é o termo de polarização que pode ser aprendido. + + + +Sem os parâmetros aprendíveis $a$ e $b$, a distribuição do vetor de saída $y$ terá média fixa 0 e padrão 1. O fator de escala $a$ e o termo de polarização $b$ mantêm o poder de representação da rede, *ou seja,* os valores de saída ainda podem estar acima de qualquer faixa específica. Observe que $a$ e $b$ não invertem a normalização, porque eles são parâmetros aprendíveis e são muito mais estáveis do que $\mu$ e $\sigma$. + + + +
+
+Figure 4: Operações de Normalização. +
+ + + +Existem várias maneiras de normalizar o vetor de entrada, com base em como selecionar amostras para normalização. A Figura 4 lista 4 abordagens diferentes de normalização, para um minilote de $N$ imagens de altura $H$ e largura $W$, com canais $C$: + + + +- *Normalização em lote (Batch Norm)*: a normalização é aplicada apenas em um canal da entrada. Esta é a primeira proposta e a abordagem mais conhecida. Leia [Como treinar seu ResNet 7: norma de lote](https://myrtle.ai/learn/how-to-train-your-resnet-7-batch-norm/) para obter mais informações. +- *Normalização de camada (Layer Norm)*: a normalização é aplicada dentro de uma imagem em todos os canais. +- *Normalização de instância (Instance Norm)*: a normalização é aplicada apenas sobre uma imagem e um canal. +- *Normalização de grupo (Group Norm)*: a normalização é aplicada sobre uma imagem, mas em vários canais. Por exemplo, os canais 0 a 9 são um grupo, os canais 10 a 19 são outro grupo e assim por diante. Na prática, o tamanho do grupo é quase sempre de 32. Essa é a abordagem recomendada por Aaron Defazio, pois tem um bom desempenho na prática e não conflita com o SGD. + + + +Na prática, a norma de lote e a norma de grupo funcionam bem para problemas de visão computacional, enquanto a norma de camada e a norma de instância são muito usadas para problemas de linguagem. + + + + +### Por que a normalização ajuda? + + + +Embora a normalização funcione bem na prática, as razões por trás de sua eficácia ainda são contestadas. Originalmente, a normalização é proposta para reduzir a "mudança interna da covariável" ("internal covariate shift"), mas alguns estudiosos provaram que estava errada em experimentos. No entanto, a normalização claramente tem uma combinação dos seguintes fatores: + + + +- Redes com camadas de normalização são mais fáceis de otimizar, permitindo o uso de maiores taxas de aprendizado. A normalização tem um efeito de otimização que acelera o treinamento das redes neurais. +- As estimativas de média/padrão são ruidosas devido à aleatoriedade das amostras no lote. Este "ruído" extra resulta em melhor generalização em alguns casos. A normalização tem um efeito de regularização. +- A normalização reduz a sensibilidade à inicialização do peso. + + + +Como resultado, a normalização permite que você seja mais "descuidado" - você pode combinar quase todos os blocos de construção de rede neural e ter uma boa chance de treiná-la sem ter que considerar o quão mal condicionada ela pode estar. + + + + +### Considerações práticas + + + +É importante que a retropropagação seja feita por meio do cálculo da média e do padrão, bem como a aplicação da normalização: o treinamento da rede irá divergir de outra forma. O cálculo da propagação reversa é bastante difícil e sujeito a erros, mas o PyTorch é capaz de calculá-lo automaticamente para nós, o que é muito útil. Duas classes de camada de normalização em PyTorch estão listadas abaixo: + + + +```python +torch.nn.BatchNorm2d(num_features, ...) +torch.nn.GroupNorm(num_groups, num_channels, ...) +``` + + + +A normalização em lote (batch norm) foi o primeiro método desenvolvido e é o mais amplamente conhecido. No entanto, **Aaron Defazio recomenda usar a normalização de grupo (group norm)** ao invés da primeira. Ele é mais estável, teoricamente mais simples e geralmente funciona melhor. O tamanho do grupo 32 é um bom padrão. + + + +Observe que para normalização em lote e normalização de instância, a média/padrão usada é fixada após o treinamento, em vez de recalculada toda vez que a rede é avaliada, porque várias amostras de treinamento são necessárias para realizar a normalização. Isso não é necessário para normalização de grupo e normalização de camada, uma vez que sua normalização é sobre apenas uma amostra de treinamento. + + + + +## [A morte da otimização](https://www.youtube.com/watch?v=--NZb480zlg&t=4817s) + + + +Às vezes, podemos invadir um campo sobre o qual nada sabemos e melhorar a forma como eles estão implementando as coisas. Um exemplo é o uso de redes neurais profundas no campo da exames de Ressonância Magnética (MRI) para acelerar a reconstrução de imagens de MRI. + + + +
+
+Figure 5: Às vezes realmente funciona! +
+ + + + +### Reconstrução de Ressonância Magnética + + + +No problema de reconstrução tradicional de exames de ressonância magnética (MRI), os dados brutos são obtidos de uma máquina de MRI e uma imagem é reconstruída a partir dele usando um pipeline/algoritmo simples. As máquinas de ressonância magnética capturam dados em um domínio de Fourier bidimensional, uma linha ou uma coluna por vez (a cada poucos milissegundos). Esta entrada bruta é composta por uma frequência e um canal de fase e o valor representa a magnitude de uma onda senoidal com aquela frequência e fase específicas. Em termos simples, pode ser pensada como uma imagem de valor complexo, possuindo um canal real e outro imaginário. Se aplicarmos uma transformada inversa de Fourier nesta entrada, ou seja, somarmos todas essas ondas senoidais ponderadas por seus valores, podemos obter a imagem anatômica original. + + + +
+
+Fig. 6: Reconstrução de ressonância magnética +

+ + + +Existe atualmente um mapeamento linear para ir do domínio de Fourier ao domínio da imagem e é muito eficiente, levando literalmente milissegundos, não importa o tamanho da imagem. Mas a questão é: podemos fazer isso ainda mais rápido? + + + + +### Ressonância magnética acelerada + + + +O novo problema que precisa ser resolvido é a ressonância magnética acelerada, onde por aceleração queremos dizer tornar o processo de reconstrução por ressonância magnética muito mais rápido. Queremos operar as máquinas mais rapidamente e ainda ser capazes de produzir imagens de qualidade idêntica. Uma maneira de fazer isso e a maneira mais bem-sucedida até agora tem sido não capturar todas as colunas da varredura de ressonância magnética. Podemos pular algumas colunas aleatoriamente, embora seja útil na prática capturar as colunas do meio, pois elas contêm muitas informações na imagem, mas fora delas apenas capturamos aleatoriamente. O problema é que não podemos mais usar nosso mapeamento linear para reconstruir a imagem. A imagem mais à direita na Figura 7 mostra a saída de um mapeamento linear aplicado ao espaço de Fourier subamostrado. É claro que esse método não nos dá resultados muito úteis e que há espaço para fazer algo um pouco mais inteligente. + + + +
+
+Fig.: Mapeamento linear no espaço de Fourier subamostrado +

+ + + + +### Compressed sensing + + + +Um dos maiores avanços na matemática teórica por muito tempo foi o sensoriamento comprimido. Um artigo de Candes et al. mostrou que, teoricamente, podemos obter uma reconstrução perfeita a partir da subamostra da imagem do domínio de Fourier . Em outras palavras, quando o sinal que estamos tentando reconstruir é esparso ou esparsamente estruturado, então é possível reconstruí-lo perfeitamente a partir de menos medições. Mas existem alguns requisitos práticos para que isso funcione - não precisamos amostrar aleatoriamente, em vez disso, precisamos amostrar incoerentemente - embora, na prática, as pessoas acabem apenas amostrando aleatoriamente. Além disso, leva o mesmo tempo para amostrar uma coluna inteira ou meia coluna, portanto, na prática, também amostramos colunas inteiras. + + + +Outra condição é que precisamos ter *esparsidade* em nossa imagem, onde por esparsidade queremos dizer muitos zeros ou pixels pretos na imagem. A entrada bruta pode ser representada esparsamente se fizermos uma decomposição do comprimento de onda, mas mesmo essa decomposição nos dá uma imagem aproximadamente esparsa e não exatamente esparsa. Portanto, essa abordagem nos dá uma reconstrução muito boa, mas não perfeita, como podemos ver na Figura 8. No entanto, se a entrada fosse muito esparsa no domínio do comprimento de onda, com certeza obteríamos uma imagem perfeita. + + + +
+
+Figure 8: Sensoriamento comprimido +

+ + + +O sensoriamento comprimido é baseado na teoria da otimização. A maneira como podemos obter essa reconstrução é resolvendo um problema de mini-otimização que tem um termo de regularização adicional: + + + +$$ +\hat{x} = \arg\min_x \frac{1}{2} \Vert M (\mathcal{F}(x)) - y \Vert^2 + \lambda TV(x) +$$ + + + +onde $M$ é a função de máscara que zera as entradas não amostradas, $\mathcal{F}$ é a transformação de Fourier, $y$ são os dados observados do domínio de Fourier, $\lambda$ é a força da penalidade de regularização e $V$ é a função de regularização. + + + +O problema de otimização deve ser resolvido para cada etapa de tempo ou cada "fatia" em uma ressonância magnética, que geralmente leva muito mais tempo do que a própria varredura. Isso nos dá outro motivo para encontrar algo melhor. + + + + +### Quem precisa de otimização? + + + +Em vez de resolver o pequeno problema de otimização em cada etapa do tempo, por que não usar uma grande rede neural para produzir a solução necessária diretamente? Nossa esperança é que possamos treinar uma rede neural com complexidade suficiente para que essencialmente resolva o problema de otimização em uma etapa e produza uma saída que seja tão boa quanto a solução obtida ao resolver o problema de otimização em cada etapa de tempo. + + + +$$ +\hat{x} = B(y) +$$ + + + +onde $B$ é o nosso modelo de aprendizado profundo e $y$ são os dados observados do domínio de Fourier. + + + +Há 15 anos, essa abordagem era difícil - mas hoje em dia é muito mais fácil de implementar. A Figura 9 mostra o resultado de uma abordagem de aprendizado profundo para esse problema e podemos ver que a saída é muito melhor do que a abordagem de detecção compactada e é muito semelhante ao exame de imagem real. + + + +
+
+Figure 9: Abordagem com aprendizado profundo +

+ + + +O modelo usado para gerar essa reconstrução usa um otimizador ADAM, camadas de normalização de norma de grupo e uma rede neural convolucional baseada em U-Net. Essa abordagem está muito próxima de aplicações práticas e esperamos ver esses exames de ressonância magnética acelerados acontecendo na prática clínica em alguns anos. \ No newline at end of file diff --git a/docs/pt/week05/05-3.md b/docs/pt/week05/05-3.md new file mode 100644 index 000000000..029a327af --- /dev/null +++ b/docs/pt/week05/05-3.md @@ -0,0 +1,490 @@ +--- +lang: pt +lang-ref: ch.05-3 +title: Noções básicas sobre convoluções e mecanismo de diferenciação automática +lecturer: Alfredo Canziani +authors: Leyi Zhu, Siqi Wang, Tao Wang, Anqi Zhang +date: 25 Feb 2020 +translator: Felipe Schiavon +translation-date: 14 Nov 2021 +--- + + + + +## [Entendendo a convolução 1D](https://www.youtube.com/watch?v=eEzCZnOFU1w&t=140s) + + + +Nesta parte discutiremos a convolução, uma vez que gostaríamos de explorar a esparsidade, estacionariedade e composicionalidade dos dados. + + + +Ao invés de usar a matriz $A$ discutida na [semana anterior]({{site.baseurl}}/pt/week04/04-1), vamos alterar a largura da matriz para o tamanho do kernel $k$. Portanto, cada linha da matriz é um kernel. Podemos usar os kernels os empilhando e deslocando (veja a Fig. 1). Então podemos ter $m$ camadas de altura $n-k+1$. + + +
+1
+Fig 1: Ilustração de uma Convolução 1D +
+ + + +A saída são $m$ (espessura) vetores de tamanho $n-k+1$. + + + +
+2
+Fig 2: Resultado da Convolução 1D +
+ + + +Além disso, um único vetor de entrada pode ser visto como um sinal monofônico. + + + +
+3
+Fig 3: Monofônico Signal +
+ + + +Agora, a entrada $x$ é o mapeamento + + + +$$ +x:\Omega\rightarrow\mathbb{R}^{c} +$$ + + + +onde $\Omega = \lbrace 1, 2, 3, \cdots \rbrace \subset \mathbb{N}^1$ (uma vez que este é um sinal $1$ dimensional / tem um domínio unidimensional) e, neste caso, o canal o número $c$ é $1$. Quando $c = 2$, isso se torna um sinal estereofônico. + + + +Para a convolução 1D, podemos apenas calcular o produto escalar, kernel por kernel (consulte a Figura 4). + + + +
+4
+Fig 4: Produto escalar camada por camada da convolução 1D +
+ + + + +## [Dimensões das larguras dos kernels e saídas no PyTorch](https://www.youtube.com/watch?v=eEzCZnOFU1w&t=1095s) + + + +Dicas: Podemos usar ***ponto de interrogação*** no IPython para obter acesso à documentação das funções. Por exemplo, + + + +```python +Init signature: +nn.Conv1d( + in_channels, # número de canais na imagem de entrada + out_channels, # número de canais produzidos pela convolução + kernel_size, # tamanho do kernel convolvente + stride=1, # stride (passo) da convolução + padding=0, # zero-padding (preenchimento com zero) adicionado nos dois lados da entrada + dilation=1, # espaçamento entre os elementos do kernel + groups=1, # número de conexões bloqueadas da entrada para a saída + bias=True, # se `True`, adiciona um viés "aprendível" na saída + padding_mode='zeros', # modo de preenchimento, aceita valores `zeros` e `circular` +) +``` + + + + +### Convolução 1D + + + +Temos $1$ convolução dimensional indo de $2$ canais (sinal estereofônico) para $16$ canais ($16$ kernels) com tamanho de kernel de $3$ e *stride* (passo) de $1$. Temos então $16$ kernels com espessura $2$ e comprimento $3$. Vamos supor que o sinal de entrada tenha um lote de tamanho $1$ (um sinal), $2$ canais e $64$ amostras. A camada de saída resultante tem $1$ sinal, $16$ canais e o comprimento do sinal é $62$ ($=64-3+1$). Além disso, se gerarmos o tamanho do enviesamento, descobriremos que o tamanho do viés é $16$, já que temos um viés para cada peso. + + + +```python +conv = nn.Conv1d(2, 16, 3) # 2 canais (sinal estéreo), 16 kernels de tamanho 3 +conv.weight.size() # saída: torch.Size([16, 2, 3]) +conv.bias.size() # saída: torch.Size([16]) +x = torch.rand(1, 2, 64) # lote de tamanho 1, 2 canais, 64 amostras +conv(x).size() # saída: torch.Size([1, 16, 62]) +conv = nn.Conv1d(2, 16, 5) # 2 canais, 16 kernels de tamanho 5 +conv(x).size() # saída: torch.Size([1, 16, 60]) + +``` + + + + +### Convolução 2D + + + +Primeiro definimos os dados de entrada como $1$ amostra, $20$ canais (digamos, estamos usando uma imagem hiperespectral) com altura $64$ e largura $128$. A convolução 2D tem $20$ canais de entrada e $16$ kernels com tamanho de $3\times 5$. Após a convolução, os dados de saída têm $1$ amostra, $16$ canais com altura $62$ ($=64-3+1$) e largura $124$ ($=128-5+1$). + + + +```python +x = torch.rand(1, 20, 64, 128) # 1 amostra, 20 canais, altura 64 e largura 128 +conv = nn.Conv2d(20, 16, (3, 5)) # 20 canais, 16 kernels, kernel de tamanho 3 x 5 +conv.weight.size() # saída: torch.Size([16, 20, 3, 5]) +conv(x).size() # saída: torch.Size([1, 16, 62, 124]) +``` + + + +Se quisermos atingir a mesma dimensionalidade, podemos ter preenchimentos. Continuando o código acima, podemos adicionar novos parâmetros à função de convolução: `stride = 1` e` padding = (1, 2) `, o que significa $1$ em $y$ direction ($1$ no topo e $1$ na parte inferior) e $2$ na direção $x$. Então, o sinal de saída tem o mesmo tamanho em comparação com o sinal de entrada. O número de dimensões necessárias para armazenar a coleção de kernels ao realizar a convolução 2D é $4$. + + + +```python +# 20 canais, 16 kernels de tamanho 3 x 5, stride de 1, preenchimento (padding) de 1 e 2 +conv = nn.Conv2d(20, 16, (3, 5), 1, (1, 2)) +conv(x).size() # saída: torch.Size([1, 16, 64, 128]) +``` + + + + +## [Como funciona o gradiente automático?](https://www.youtube.com/watch?v=eEzCZnOFU1w&t=1634s) + + + +Nesta seção, vamos pedir ao torch para verificar todos os cálculos sobre os tensores para que possamos realizar o cálculo das derivadas parciais. + + + +- Crie um tensor $2\times2$ $\boldsymbol{x}$ com capacidades de acumulação de gradiente; +- Deduza $2$ de todos os elementos de $\boldsymbol{x}$ e obtenha $\boldsymbol{y}$; (Se imprimirmos `y.grad_fn`, obteremos` `, o que significa que `y` é gerado pelo módulo da subtração $\boldsymbol{x}-2$. Também podemos usar `y.grad_fn.next_functions[0][0].variable` para derivar o tensor original.) +- Faça mais operações: $\boldsymbol{z}=3 \boldsymbol{y}^2 $; +- Calcule a média de $\boldsymbol{z}$. + + + +
+5
+Fig 5: Fluxograma do Exemplo de gradiente automático +
+ + + +A retropropagação (backpropagation) é usada para calcular os gradientes. Neste exemplo, o processo de retropropagação pode ser visto como o cálculo do gradiente $\frac{d\boldsymbol{a}}{d\boldsymbol{x}}$. Depois de calcular $\frac{d\boldsymbol{a}}{d\boldsymbol{x}}$ manualmente como uma validação, podemos descobrir que a execução de `a.backward()` nos dá o mesmo valor de *x.grad* como nosso cálculo. + + + +Aqui está o processo de cálculo da retropropagação manualmente: + + + +$$ +\begin{aligned} +a &= \frac{1}{4} (z_1 + z_2 + z_3 + z_4) \\ +z_i &= 3y_i^2 = 3(x_i-2)^2 \\ +\frac{da}{dx_i} &= \frac{1}{4}\times3\times2(x_i-2) = \frac{3}{2}x_i-3 \\ +x &= \begin{pmatrix} 1&2\\3&4\end{pmatrix} \\ +\left(\frac{da}{dx_i}\right)^\top &= \begin{pmatrix} 1.5-3&3-3\\[2mm]4.5-3&6-3\end{pmatrix}=\begin{pmatrix} -1.5&0\\[2mm]1.5&3\end{pmatrix} +\end{aligned} +$$ + + + +Sempre que você usa derivada parcial em PyTorch, obtém a mesma forma dos dados originais. Mas a coisa jacobiana correta deveria ser a transposição. + + + + +### Do básico ao mais louco + + + +Agora temos um vetor $1\times3$ $x$, atribua $y$ ao dobro de $x$ e continue dobrando $y$ até que sua norma seja menor que $1000$. Devido à aleatoriedade que temos para $x$, não podemos saber diretamente o número de iterações quando o procedimento termina. + + + +```python +x = torch.randn(3, requires_grad=True) + +y = x * 2 +i = 0 +while y.data.norm() < 1000: + y = y * 2 + i += 1 +``` + + + +No entanto, podemos inferir isso facilmente conhecendo os gradientes que temos. + + + +```python +gradients = torch.FloatTensor([0.1, 1.0, 0.0001]) +y.backward(gradients) + +print(x.grad) +tensor([1.0240e+02, 1.0240e+03, 1.0240e-01]) +print(i) +9 +``` + + + +Quanto à inferência, podemos usar `requires_grad=True` para rotular que queremos rastrear o acúmulo de gradiente conforme mostrado abaixo. Se omitirmos `requires_grad=True` na declaração de $x$ ou $w$ e chamar`backward ()`em $z$, haverá um erro de execução devido a não termos acumulação de gradiente em $x$ ou $w$. + + + +```python +# Tanto x quanto w que permitem o acúmulo de gradiente +x = torch.arange(1., n + 1, requires_grad=True) +w = torch.ones(n, requires_grad=True) +z = w @ x +z.backward() +print(x.grad, w.grad, sep='\n') +``` + + + +E, podemos usar o comando `with torch.no_grad()` para omitir o acúmulo de gradiente. + + + + +```python +x = torch.arange(1., n + 1) +w = torch.ones(n, requires_grad=True) + +# Todos os tensores do torch não terão gradientes acumulados +with torch.no_grad(): + z = w @ x + +try: + z.backward() # PyTorch vai lançar um erro aqui, pois z não tem acumulador de gradientes +except RuntimeError as e: + print('RuntimeError!!! >:[') + print(e) +``` + + + + +## Mais coisas - gradientes personalizados + + + +Além disso, em vez de operações numéricas básicas, podemos criar nossos próprios módulos / funções, que podem ser plugados no grafo da rede neural. O Jupyter Notebook pode ser encontrado [aqui](https://github.com/Atcold/pytorch-Deep-Learning/blob/master/extra/b-custom_grads.ipynb). + + + +Para fazer isso, precisamos herdar `torch.autograd.Function` e substituir as funções `forward ()` e `backward()`. Por exemplo, se quisermos treinar redes, precisamos obter a passagem pelo *forward* e saber as derivadas parciais da entrada em relação à saída, de forma que possamos usar este módulo em qualquer tipo de ponto do código. Então, usando retropropagação (regra da cadeia), podemos conectar a coisa em qualquer lugar na cadeia de operações, desde que conheçamos as derivadas parciais da entrada em relação à saída. + + + +Neste caso, existem três exemplos de ***módulos personalizados*** no *notebook*, os módulos `add`,`split` e `max`. Por exemplo, o módulo de adição personalizado: + + + +```python +# Custom addition module +class MyAdd(torch.autograd.Function): + + @staticmethod + def forward(ctx, x1, x2): + # ctx is a context where we can save + # computations for backward. + ctx.save_for_backward(x1, x2) + return x1 + x2 + + @staticmethod + def backward(ctx, grad_output): + x1, x2 = ctx.saved_tensors + grad_x1 = grad_output * torch.ones_like(x1) + grad_x2 = grad_output * torch.ones_like(x2) + # need to return grads in order + # of inputs to forward (excluding ctx) + return grad_x1, grad_x2 +``` + + + +Se adicionarmos duas coisas e obtivermos uma saída, precisamos sobrescrever a função forward desta forma. E quando descemos para fazer a propagação reversa, os gradientes são copiados em ambos os lados. Portanto, sobrescrevemos a função de retrocesso copiando. + + + +Para `split` e `max`, veja o código de como sobrescrevemos as funções de avanço e retrocesso no *bloco de notas*. Se viermos da mesma coisa e **Dividir**, ao descermos fazendo gradientes, devemos somar / somar. Para `argmax`, ele seleciona o índice da coisa mais alta, então o índice da mais alta deve ser $1$ enquanto os outros devem ser $0$. Lembre-se, de acordo com diferentes módulos personalizados, precisamos sobrescrever sua própria passagem do *forward* e como eles fazem os gradientes na função *backward*. diff --git a/docs/pt/week05/05.md b/docs/pt/week05/05.md new file mode 100644 index 000000000..10ca81a95 --- /dev/null +++ b/docs/pt/week05/05.md @@ -0,0 +1,40 @@ +--- +lang: pt +lang-ref: ch.05 +title: Semana 5 +translation-date: 05 Nov 2021 +translator: Felipe Schiavon +--- + + + +## Aula parte A + + + +Começamos apresentando o Gradiente Descendente. Discutimos a intuição e também falamos sobre como os tamanhos dos passos desempenham um papel importante para se chegar à solução. Em seguida, passamos para Gradiente Descendente Estocástico (SGD) e seu desempenho em comparação com Gradiente Descendente completo (Full Batch GD). Por fim, falamos sobre as atualizações de momento, especificamente as duas regras de atualização, a intuição por trás do momento e seu efeito na convergência. + + + +## Aula parte B + + + +Discutimos métodos adaptativos para SGD, como RMSprop e ADAM. Também falamos sobre camadas de normalização e seus efeitos no processo de treinamento das redes neurais. Finalmente, discutimos um exemplo do mundo real de redes neurais sendo usadas na indústria para tornar os exames de ressonância magnética mais rápidos e eficientes. + + + +## Prática + + + +Revisamos brevemente as multiplicações de matrizes e, em seguida, discutimos as convoluções. O ponto principal é que usamos kernels por empilhamento e deslocamento. Primeiro entendemos a convolução de uma dimensão (1D) manualmente e, em seguida, usamos o PyTorch para aprender a dimensão dos kernels e da largura da saída em exemplos de convoluções de uma (1D) e duas dimensões (2D). Além disso, usamos o PyTorch para aprender sobre como o funciona o gradiente automático e os gradientes customizados. + diff --git a/docs/pt/week05/lecture05.sbv b/docs/pt/week05/lecture05.sbv new file mode 100644 index 000000000..402b9231e --- /dev/null +++ b/docs/pt/week05/lecture05.sbv @@ -0,0 +1,3572 @@ +0:00:00.000,0:00:04.410 +Tudo bem, como você pode ver hoje não temos Yann. Yann está em outro lugar + +0:00:04.410,0:00:09.120 +se divertindo. Olá Yan. Ok, então é hoje que temos + +0:00:09.120,0:00:13.740 +Aaron DeFazio ele é um cientista de pesquisa no Facebook trabalhando principalmente em + +0:00:13.740,0:00:16.619 +otimização ele está lá nos últimos três anos + +0:00:16.619,0:00:21.900 +e antes de ser cientista de dados na Ambiata e depois estudante da + +0:00:21.900,0:00:27.599 +Australian National University, então por que não damos uma salva de palmas ao + +0:00:27.599,0:00:37.350 +nosso palestrante hoje falarei sobre otimização e se tivermos tempo no + +0:00:37.350,0:00:42.739 +acabar com a morte da otimização, então esses são os tópicos que abordarei hoje + +0:00:42.739,0:00:47.879 +agora a otimização está no centro do aprendizado de máquina e algumas das coisas + +0:00:47.879,0:00:52.680 +vai falar hoje será usado todos os dias no seu papel + +0:00:52.680,0:00:56.640 +potencialmente como um cientista aplicado ou mesmo como um cientista de pesquisa ou um + +0:00:56.640,0:01:01.590 +cientista e vou me concentrar na aplicação desses métodos + +0:01:01.590,0:01:05.850 +particularmente, em vez da teoria por trás deles, parte da razão para isso + +0:01:05.850,0:01:10.260 +é que não entendemos completamente todos esses métodos, então para eu vir até aqui + +0:01:10.260,0:01:15.119 +e dizer que é por isso que funciona, eu estaria simplificando demais as coisas, mas o que posso + +0:01:15.119,0:01:22.320 +dizer é como usá-los como sabemos que eles funcionam em determinadas situações e + +0:01:22.320,0:01:28.320 +qual pode ser o melhor método para treinar sua rede neural e + +0:01:28.320,0:01:31.770 +apresentá-lo ao tópico de otimização, preciso começar com o + +0:01:31.770,0:01:36.720 +pior método do mundo gradiente descendente e explicarei em um minuto por que + +0:01:36.720,0:01:43.850 +é o pior método, mas para começar vamos usar o mais genérico + +0:01:43.850,0:01:47.549 +formulação de otimização agora os problemas que você vai considerar + +0:01:47.549,0:01:51.659 +terá mais estrutura do que isso, mas é muito útil em notação para + +0:01:51.659,0:01:56.969 +comece desta forma, então falamos sobre uma função f agora estamos tentando provar + +0:01:56.969,0:02:03.930 +propriedades do nosso otimizador assumirão estrutura adicional em f, mas em + +0:02:03.930,0:02:07.049 +praticar a estrutura em nossas redes neurais essencialmente obedecem a nenhuma das + +0:02:07.049,0:02:09.239 +suposições nenhuma das suposições que as pessoas fazem em + +0:02:09.239,0:02:12.030 +prática eu vou começar com o F genérico + +0:02:12.030,0:02:17.070 +e vamos supor que é contínuo e diferenciável mesmo que já estejamos + +0:02:17.070,0:02:20.490 +entrando no reino de suposições incorretas, uma vez que as redes neurais + +0:02:20.490,0:02:25.170 +a maioria das pessoas está usando na prática hoje em dia não são diferenciáveis, em vez disso você + +0:02:25.170,0:02:29.460 +tem um subdiferencial equivalente que você pode essencialmente conectar a todos esses + +0:02:29.460,0:02:33.570 +fórmulas e se você cruzar os dedos não há teoria para apoiar isso + +0:02:33.570,0:02:38.910 +deve funcionar para que o método de gradiente descendente seja mostrado aqui, é um iterativo + +0:02:38.910,0:02:44.790 +método para que você comece em um ponto k igual a zero e a cada passo você atualiza seu + +0:02:44.790,0:02:49.410 +ponto e aqui vamos usar W para representar nossa iteração atual ou + +0:02:49.410,0:02:54.000 +sendo a nomenclatura padrão para o ponto da sua rede neural isso w + +0:02:54.000,0:03:00.420 +será uma grande coleção de pesos um tensor de peso por camada, mas notação + +0:03:00.420,0:03:03.540 +nós meio que esmagamos a coisa toda em um único vetor e você pode + +0:03:03.540,0:03:09.000 +imagine apenas fazer isso literalmente remodelando todos os seus vetores para todos os seus + +0:03:09.000,0:03:13.740 +tensores dois vetores e apenas concatená-los e esse método é + +0:03:13.740,0:03:17.519 +notavelmente simples, tudo o que fazemos é seguir a direção do gradiente negativo + +0:03:17.519,0:03:24.750 +e a razão para isso é bem simples, então deixe-me dar-lhe um diagrama e + +0:03:24.750,0:03:28.410 +talvez isso ajude a explicar exatamente por que seguir o gradiente negativo + +0:03:28.410,0:03:33.570 +direção é uma boa ideia, então não sabemos o suficiente sobre nossa função para fazer + +0:03:33.570,0:03:38.760 +melhor, esta é uma ideia de alto nível quando estamos otimizando uma função que analisamos + +0:03:38.760,0:03:45.060 +o cenário o cenário de otimização localmente então pelo cenário de otimização I + +0:03:45.060,0:03:49.230 +significa o domínio de todos os pesos possíveis da nossa rede agora não sabemos o que é + +0:03:49.230,0:03:53.459 +vai acontecer se usarmos pesos específicos em sua rede, não sabemos se + +0:03:53.459,0:03:56.930 +será melhor na tarefa para a qual estamos tentando treiná-lo ou pior, mas sabemos + +0:03:56.930,0:04:01.530 +localmente é o ponto que está atualmente ad e o gradiente e este gradiente + +0:04:01.530,0:04:05.190 +fornece algumas informações sobre uma direção que podemos seguir nesse + +0:04:05.190,0:04:09.870 +pode melhorar o desempenho de nossa rede ou, neste caso, reduzir o valor + +0:04:09.870,0:04:14.340 +da nossa função foram minimizados aqui nesta configuração esta configuração geral + +0:04:14.340,0:04:19.380 +minimizar uma função é essencialmente treinar em sua rede, portanto, minimizar + +0:04:19.380,0:04:23.520 +a perda lhe dará o melhor desempenho em sua tarefa de classificação + +0:04:23.520,0:04:26.550 +ou o que você está tentando fazer e porque só olhamos para o mundo + +0:04:26.550,0:04:31.110 +localmente aqui este gradiente é basicamente a melhor informação que temos e você pode + +0:04:31.110,0:04:36.270 +pense nisso como descer um vale onde você começa em algum lugar horrível + +0:04:36.270,0:04:39.600 +dedo mindinho parte da paisagem o topo de uma montanha por exemplo e você viaja + +0:04:39.600,0:04:43.590 +a partir daí e em cada ponto você segue a direção perto de você que tem + +0:04:43.590,0:04:50.040 +o mais triste a descida mais íngreme e, de fato, o método de classificação % + +0:04:50.040,0:04:53.820 +às vezes é chamado de método de descida mais íngreme e essa direção + +0:04:53.820,0:04:57.630 +mudar à medida que você se move no espaço agora se você se mover localmente por apenas um + +0:04:57.630,0:05:02.040 +quantidade infinitesimal assumindo essa suavidade que mencionei antes e que + +0:05:02.040,0:05:04.740 +não é verdade na prática, mas chegaremos a isso assumindo que + +0:05:04.740,0:05:08.280 +suavidade este pequeno passo só irá alterar o gradiente um pouco para que + +0:05:08.280,0:05:11.820 +a direção em que você está viajando é pelo menos uma boa direção quando você toma + +0:05:11.820,0:05:18.120 +pequenos passos e nós essencialmente apenas seguimos este caminho tomando como passos maiores + +0:05:18.120,0:05:20.669 +como podemos percorrer a paisagem até chegarmos + +0:05:20.669,0:05:25.229 +o vale na parte inferior que é o minimizador nossa função agora há um + +0:05:25.229,0:05:30.690 +pouco mais podemos dizer para algumas classes de problemas e vou usar o + +0:05:30.690,0:05:34.950 +classe de problema mais simplista que podemos apenas porque é a única coisa que eu + +0:05:34.950,0:05:39.210 +pode realmente fazer qualquer matemática em um slide, então tenha paciência comigo + +0:05:39.210,0:05:44.580 +esta classe é quadrática, então para um problema de otimização quadrática nós + +0:05:44.580,0:05:51.570 +na verdade, sei um pouco apenas com base no gradiente, então primeiro um gradiente corta + +0:05:51.570,0:05:55.440 +metade de um espaço inteiro e agora ilustre isso aqui com este verde + +0:05:55.440,0:06:02.130 +linha, então estamos naquele ponto onde a linha começa perto da Linha Verde, + +0:06:02.130,0:06:05.789 +sei que a solução não pode estar no resto do espaço e isso não é verdade de + +0:06:05.789,0:06:09.930 +suas redes, mas ainda é uma diretriz genuinamente boa que queremos seguir + +0:06:09.930,0:06:13.710 +a direção do gradiente negativo pode haver melhores soluções em outros lugares + +0:06:13.710,0:06:17.910 +o espaço, mas encontrá-los é muito mais difícil do que apenas tentar encontrar o melhor + +0:06:17.910,0:06:21.300 +solução perto de onde estamos, então é isso que fazemos, tentando encontrar o melhor + +0:06:21.300,0:06:24.930 +solução perto de onde estamos, você pode imaginar que esta seja a superfície do + +0:06:24.930,0:06:28.410 +terra onde há muitas colinas e vales e não podemos esperar saber + +0:06:28.410,0:06:31.020 +algo sobre uma montanha do outro lado do planeta, mas certamente podemos + +0:06:31.020,0:06:34.559 +procure o vale logo abaixo da montanha onde estamos atualmente + +0:06:34.559,0:06:39.089 +na verdade, você pode pensar nessas funções aqui como sendo representadas com esses + +0:06:39.089,0:06:44.369 +mapas topográficos isto é o mesmo que mapas topográficos que você usa que você pode estar + +0:06:44.369,0:06:50.369 +familiarizado do planeta Terra, onde as montanhas são mostradas por esses anéis + +0:06:50.369,0:06:53.309 +agora aqui os anéis estão representando a descida, então esta é a parte inferior do + +0:06:53.309,0:06:57.839 +vale que estamos mostrando aqui, não o topo de uma colina no centro, então sim, nosso + +0:06:57.839,0:07:02.459 +gradiente elimina metade do espaço possível agora é muito razoável + +0:07:02.459,0:07:06.059 +então ir na direção encontrar esse gradiente negativo porque é meio que + +0:07:06.059,0:07:10.199 +ortogonal a esta linha que corta após o espaço e você pode ver que eu + +0:07:10.199,0:07:21.409 +peguei a indicação de ortogonal você ai a pracinha então o + +0:07:21.409,0:07:25.319 +propriedades do gradiente para passar um gradiente descendente dependem muito da + +0:07:25.319,0:07:28.889 +estrutura do problema para esses problemas quadráticos é na verdade + +0:07:28.889,0:07:32.549 +relativamente simples para caracterizar o que vai acontecer, então vou dar-lhe uma + +0:07:32.549,0:07:35.369 +um pouco de uma visão geral aqui e vou gastar alguns minutos nisso porque é + +0:07:35.369,0:07:38.339 +bastante interessante e espero que aqueles de vocês com alguma experiência em + +0:07:38.339,0:07:42.629 +álgebra linear pode seguir esta derivação, mas vamos considerar um + +0:07:42.629,0:07:47.309 +problema de otimização quadrática agora o problema indicado na caixa cinza + +0:07:47.309,0:07:53.309 +no topo você pode ver que esta é uma quadrática onde a é uma definida positiva + +0:07:53.309,0:07:58.769 +matriz podemos lidar com classes mais amplas de quadráticas e isso potencialmente + +0:07:58.769,0:08:04.649 +mas a análise é mais simples no caso positivo definido e na grade + +0:08:04.649,0:08:09.539 +dessa função é muito simples, é claro, como Aw - b e u a solução de + +0:08:09.539,0:08:13.379 +este problema tem uma forma fechada no caso de quadráticas é como inversa de um + +0:08:13.379,0:08:20.179 +vezes B agora o que fazemos é seguir os passos mostrados na caixa verde e + +0:08:20.179,0:08:26.519 +nós apenas o conectamos à distância da solução. Então isso || wₖ₊₁ – w*|| + +0:08:26.519,0:08:30.479 +é uma distância da solução, então queremos ver como isso muda ao longo do tempo e + +0:08:30.479,0:08:34.050 +a ideia é que, se estivermos nos aproximando da solução ao longo do tempo, o método é + +0:08:34.050,0:08:38.579 +convergindo, então começamos com essa distância da solução a ser plugada no + +0:08:38.579,0:08:44.509 +valor da atualização agora com um pouco de reorganização, podemos puxar + +0:08:45.050,0:08:50.950 +os termos, podemos agrupar os termos e podemos escrever B como um inverso + +0:08:50.950,0:09:05.090 +então podemos puxar ou podemos puxar a estrela W dentro dos suportes lá e + +0:09:05.090,0:09:11.960 +então obtemos essa expressão em que é a matriz vezes a distância anterior para + +0:09:11.960,0:09:16.040 +a matriz de solução vezes a solução de distância anterior agora não sabemos + +0:09:16.040,0:09:20.720 +qualquer coisa sobre quais direções esta quadrática varia mais extremamente em + +0:09:20.720,0:09:24.890 +mas não podemos limitar isso simplesmente tomando o produto do + +0:09:24.890,0:09:28.850 +matriz como norma e a distância para a solução aqui esta norma na parte inferior para + +0:09:28.850,0:09:34.070 +essa é a linha de fundo agora quando você está considerando as normas da matriz, é + +0:09:34.070,0:09:39.590 +bastante simples ver que você terá uma expressão em que + +0:09:39.590,0:09:45.710 +os valores próprios desta matriz serão 1 menos μ γ ou 1 menos + +0:09:45.710,0:09:48.950 +L γ agora a maneira como eu entendo isso é apenas olhar para quais são os eigen extremos + +0:09:48.950,0:09:54.050 +valores de a que nós os chamamos de μ e L e colocando-os no + +0:09:54.050,0:09:56.930 +expressão podemos ver quais serão os valores próprios extremos desta combinação + +0:09:56.930,0:10:03.050 +matriz I menos γ a e você tem esse valor absoluto aqui agora você pode otimizar + +0:10:03.050,0:10:06.320 +isso e obter uma taxa de aprendizado ideal para as quadráticas + +0:10:06.320,0:10:09.920 +mas essa taxa de aprendizado ideal não é robusta na prática, você provavelmente não + +0:10:09.920,0:10:16.910 +deseja usar isso, então um valor mais simples que você pode usar é 1/L. L sendo o maior + +0:10:16.910,0:10:22.420 +valor próprio e isso lhe dá essa taxa de convergência de 1 – μ/L + +0:10:22.420,0:10:29.240 +redução da distância até a solução a cada passo temos alguma dúvida aqui eu + +0:10:29.240,0:10:32.020 +sei que é um pouco denso sim sim é uma substituição de dentro + +0:10:41.120,0:10:46.010 +essa caixa cinza você vê a linha de fundo na caixa cinza sim é isso é apenas + +0:10:46.010,0:10:51.230 +a, por definição, podemos resolver o gradiente, então, tomando o gradiente para + +0:10:51.230,0:10:53.060 +zero se você vir nessa segunda linha na caixa + +0:10:53.060,0:10:55.720 +levando o gradiente para zero, então substituímos nosso gradiente por zero e + +0:10:55.720,0:11:01.910 +reorganizando você obtém a solução de forma fechada para o problema aqui para que o + +0:11:01.910,0:11:04.490 +problema com o uso dessa solução de forma fechada na prática é que temos que + +0:11:04.490,0:11:08.420 +inverter uma matriz e usando gradiente descendente podemos resolver este problema por + +0:11:08.420,0:11:12.920 +apenas fazendo multiplicações de matrizes, em vez disso, eu não sugiro que você + +0:11:12.920,0:11:15.560 +realmente usar essa técnica para resolver a matriz, como mencionei antes, é o + +0:11:15.560,0:11:20.750 +pior método do mundo e a taxa de convergência deste método é + +0:11:20.750,0:11:25.100 +controlado por esta nova quantidade global agora estas são notações padrão, então + +0:11:25.100,0:11:27.950 +estamos indo da álgebra linear onde você fala sobre o min e Max eigen + +0:11:27.950,0:11:33.430 +valor à notação normalmente usada no campo da otimização. + +0:11:33.430,0:11:39.380 +μ é o menor valor próprio L sendo o maior valor próprio e este μ/L é o + +0:11:39.380,0:11:44.570 +inverso do número de condição número de condição sendo L/μ isso + +0:11:44.570,0:11:51.140 +fornece uma ampla caracterização da rapidez com que os métodos de otimização + +0:11:51.140,0:11:57.440 +trabalhar neste problema e estes termos militares eles não existem para + +0:11:57.440,0:12:02.870 +redes neurais apenas nas situações mais simples temos L existe + +0:12:02.870,0:12:06.740 +e nós essencialmente nunca temos μ existindo, no entanto, queremos falar + +0:12:06.740,0:12:10.520 +sobre as redes de rede serem polarizadas e bem condicionadas e + +0:12:10.520,0:12:14.930 +mal condicionado seria tipicamente alguma aproximação de L é muito grande + +0:12:14.930,0:12:21.260 +e bem condicionado talvez L seja muito próximo de um, então o tamanho do passo que podemos + +0:12:21.260,0:12:27.770 +selecionar em um treinamento de verão depende muito dessas constantes, então vamos + +0:12:27.770,0:12:30.800 +me dar um pouco de intuição para tamanhos de passos e isso é muito + +0:12:30.800,0:12:34.640 +importante na prática Eu mesmo acho que muito do meu tempo é gasto tratando + +0:12:34.640,0:12:40.310 +taxas de aprendizagem e tenho certeza que você estará envolvido em um procedimento semelhante, então temos + +0:12:40.310,0:12:45.740 +algumas situações que podem ocorrer se usarmos uma taxa de aprendizado muito baixa + +0:12:45.740,0:12:49.310 +descobriremos que fazemos progressos constantes em direção à solução, aqui estamos + +0:12:49.310,0:12:56.480 +minimizando um pouco 1d quadrático e por progresso constante quero dizer que cada + +0:12:56.480,0:13:00.920 +iteração o gradiente fica no buffer na mesma direção e você faz semelhante + +0:13:00.920,0:13:05.420 +progride à medida que você se aproxima da solução, isso é mais lento do que é possível, então + +0:13:05.420,0:13:09.910 +o que você gostaria de fazer idealmente é ir direto para a solução para um quadrático + +0:13:09.910,0:13:12.650 +especialmente um 1d como este que vai ser bem direto + +0:13:12.650,0:13:16.340 +haverá um tamanho de passo exato que levará você até a solução + +0:13:16.340,0:13:20.810 +mas geralmente você não pode fazer isso e o que você normalmente deseja usar é + +0:13:20.810,0:13:26.150 +na verdade, um tamanho de passo um pouco acima do ideal e isso é para vários + +0:13:26.150,0:13:29.570 +razões que tende a ser mais rápido na prática, temos que ter muito, muito cuidado + +0:13:29.570,0:13:33.800 +porque você obtém divergência e o termo divergência significa que as iterações + +0:13:33.800,0:13:37.160 +ficar mais longe do que da solução em vez de se aproximar, isso normalmente + +0:13:37.160,0:13:42.530 +acontecer se você usar duas taxas de aprendizado maiores, infelizmente para nós queremos usar + +0:13:42.530,0:13:45.590 +taxas de aprendizado o maior possível para obter o aprendizado o mais rápido possível, + +0:13:45.590,0:13:50.180 +estamos sempre à beira da divergência, na verdade, é muito raro que você veja + +0:13:50.180,0:13:55.400 +que os gradientes sigam esta bela trajetória onde todos apontam para o mesmo + +0:13:55.400,0:13:58.670 +direção até chegar à solução o que quase sempre acontece + +0:13:58.670,0:14:02.960 +prática especialmente com invariantes gradientes descendentes é que você observa + +0:14:02.960,0:14:06.770 +esse comportamento de ziguezague agora não podemos ver ziguezague em milhões + +0:14:06.770,0:14:10.940 +espaços dimensionais nos quais treinamos suas redes, mas é muito evidente em + +0:14:10.940,0:14:15.680 +esses gráficos 2d de uma quadrática, então aqui estou mostrando os conjuntos de níveis que você pode ver + +0:14:15.680,0:14:20.560 +os números ou o valor da função indicado lá nos conjuntos de nível e + +0:14:20.560,0:14:27.830 +quando usamos uma taxa de aprendizado que é boa, não ótima, mas boa, chegamos bem perto + +0:14:27.830,0:14:31.760 +para esse ponto azul a solução é para os 10 passos quando usamos uma taxa de aprendizado + +0:14:31.760,0:14:35.450 +que parece melhor porque não está oscilando é bem comportado quando + +0:14:35.450,0:14:38.330 +usar essa taxa de aprendizado, na verdade acabamos um pouco mais longe do + +0:14:38.330,0:14:42.830 +solução, então é um fato da vida que temos que lidar com essas taxas de aprendizado + +0:14:42.830,0:14:50.690 +que são estressantemente altos, é como uma corrida, você sabe que ninguém ganha uma + +0:14:50.690,0:14:55.730 +uma corrida dirigindo com segurança, então nosso treinamento em rede deve ser muito comparável ao + +0:14:55.730,0:15:01.940 +que o tópico central sobre o qual queremos falar é, na verdade, estocástico + +0:15:01.940,0:15:08.600 +otimização e este é o método que usaremos todos os dias para treinamento + +0:15:08.600,0:15:14.660 +redes neurais na prática, então a otimização de casting não é tão + +0:15:14.660,0:15:19.190 +diferente o que vamos fazer é substituir os gradientes em nosso + +0:15:19.190,0:15:25.700 +passo de descida do gradiente com uma aproximação estocástica do gradiente agora em um + +0:15:25.700,0:15:29.930 +rede neural podemos ser um pouco mais precisos aqui por aproximação estocástica + +0:15:29.930,0:15:36.310 +o que queremos dizer é o gradiente da perda para uma única instância de ponto de dados único + +0:15:36.310,0:15:42.970 +você pode querer chamá-lo, então eu tenho isso na notação aqui esta função + +0:15:42.970,0:15:49.430 +L é a perda de um dia o ponto aqui o ponto de dados é indexado por AI e nós + +0:15:49.430,0:15:52.970 +escreveria isso normalmente na literatura de otimização como a função + +0:15:52.970,0:15:57.380 +fᵢ e vou usar essa notação, mas você deve imaginar fᵢ como sendo a + +0:15:57.380,0:16:02.390 +perda para uma única instância I e aqui estou usando a configuração de aprendizado supervisionado + +0:16:02.390,0:16:08.330 +onde temos pontos de dados que eu rotula yᵢ então eles apontam xᵢ rótulos yᵢ o completo + +0:16:08.330,0:16:14.290 +a perda de uma função é mostrada na parte superior, é uma soma de todos esses fᵢ. Agora + +0:16:14.290,0:16:17.600 +deixe-me dar-lhe um pouco mais de explicação para o que estamos fazendo aqui estamos colocando + +0:16:17.600,0:16:24.230 +isto através de gradiente com um gradiente estocástico esta é uma aproximação ruidosa + +0:16:24.230,0:16:30.350 +e é assim que muitas vezes é explicado na configuração de otimização estocástica. + +0:16:30.350,0:16:36.440 +tem esta função o gradiente e em nossa configuração o valor esperado é igual + +0:16:36.440,0:16:41.150 +para o gradiente completo para que você possa pensar em uma etapa de descida de gradiente estocástica como + +0:16:41.150,0:16:47.210 +sendo um passo de gradiente completo na expectativa agora, isso não é realmente o + +0:16:47.210,0:16:50.480 +melhor maneira de vê-lo porque há muito mais acontecendo do que isso não é + +0:16:50.480,0:16:58.310 +apenas gradiente descendente com ruído, então deixe-me dar um pouco mais de detalhes, mas + +0:16:58.310,0:17:03.050 +primeiro eu deixo qualquer um fazer qualquer pergunta que eu tenha aqui antes de seguir em frente sim + +0:17:03.050,0:17:08.420 +mm-hmm sim, eu poderia falar um pouco mais sobre isso, mas sim, então você está certo, então + +0:17:08.420,0:17:12.500 +usar todo o seu conjunto de dados para calcular um gradiente é aqui o que quero dizer com gradiente + +0:17:12.500,0:17:17.720 +descida, também chamamos essa descida de gradiente de lote completo apenas para ficar claro agora em + +0:17:17.720,0:17:22.280 +aprendizado de máquina, praticamente sempre usamos minilotes para que as pessoas possam usar o nome + +0:17:22.280,0:17:24.620 +gradiente descendente ou algo assim quando eles estão realmente falando sobre estocástico + +0:17:24.620,0:17:29.150 +gradiente descendente e o que você mencionou é absolutamente verdade, então existem alguns + +0:17:29.150,0:17:33.920 +dificuldades de treinar redes neurais usando tamanhos de lote muito grandes e isso é + +0:17:33.920,0:17:37.010 +entendido até certo ponto e eu realmente explicarei isso no próximo + +0:17:37.010,0:17:39.230 +deslize então deixe-me chegar ao seu ponto primeiro + +0:17:39.230,0:17:45.679 +então o ponto a resposta para sua pergunta é na verdade o terceiro ponto aqui o + +0:17:45.679,0:17:50.780 +ruído na descida do gradiente estocástico induz esse fenômeno conhecido como + +0:17:50.780,0:17:54.770 +recozimento e o diagrama diretamente à direita ilustra isso + +0:17:54.770,0:18:00.260 +fenômenos para que seus cenários de treinamento de rede tenham uma estrutura irregular para + +0:18:00.260,0:18:05.330 +onde há muitos mínimos pequenos que não são bons mínimos que + +0:18:05.330,0:18:09.320 +aparecem no caminho para os bons mínimos, então a teoria de que muitas pessoas + +0:18:09.320,0:18:13.760 +subscrever é que SGD em particular o ruído induzido no gradiente + +0:18:13.760,0:18:18.919 +realmente ajuda o otimizador a pular esses mínimos ruins e a teoria é + +0:18:18.919,0:18:22.669 +que esses mínimos ruins são muito pequenos no espaço e, portanto, são fáceis de pular + +0:18:22.669,0:18:27.380 +sobre nós somos bons mínimos que resultam em bom desempenho em torno de sua própria rede + +0:18:27.380,0:18:34.070 +são maiores e mais difíceis de pular, então isso responde sua pergunta sim, além disso + +0:18:34.070,0:18:39.440 +esse ponto de vista de recozimento, existem algumas outras razões, então + +0:18:39.440,0:18:45.559 +temos muita redundância nas informações que obtemos de cada termo + +0:18:45.559,0:18:51.679 +gradiente e usar gradiente estocástico nos permite explorar muito essa redundância + +0:18:51.679,0:18:56.870 +de situações, o gradiente calculado em algumas centenas de exemplos é quase tão bom + +0:18:56.870,0:19:01.460 +como um gradiente calculado no conjunto de dados completo e muitas vezes milhares de vezes mais barato + +0:19:01.460,0:19:05.300 +dependendo do seu problema, é difícil encontrar um motivo convincente + +0:19:05.300,0:19:09.320 +usar gradiente descendente dado o sucesso do gradiente descendente estocástico + +0:19:09.320,0:19:13.809 +e isso é parte do motivo pelo qual gradiente desgostoso disse ser um dos + +0:19:15.659,0:19:19.859 +melhores erros que temos, mas o gradiente descendente é um dos piores e, de fato, precoce + +0:19:19.859,0:19:23.580 +estágios a correlação é notável este gradiente desgostoso pode ser + +0:19:23.580,0:19:28.499 +correlacionado até um coeficiente de 0,999 coeficiente de correlação para o verdadeiro + +0:19:28.499,0:19:33.869 +gradiente nessas etapas iniciais de otimização, então quero falar brevemente + +0:19:33.869,0:19:38.179 +sobre algo que você precisa saber, acho que Yann já mencionou isso + +0:19:38.179,0:19:43.259 +brevemente, mas na prática não usamos instâncias individuais em + +0:19:43.259,0:19:48.749 +gradiente descendente como usamos minilotes de instâncias, então estou usando apenas alguns + +0:19:48.749,0:19:52.649 +notação aqui, mas todo mundo usa notação diferente para mini lotes, então + +0:19:52.649,0:19:56.970 +você não deve se apegar muito à notação, mas essencialmente a cada passo + +0:19:56.970,0:20:03.149 +você tem algum lote aqui, vou chamá-lo de B um índice com I para o passo e + +0:20:03.149,0:20:09.299 +você basicamente usa a média dos gradientes sobre este mini lote que é + +0:20:09.299,0:20:13.470 +um subconjunto de seus dados em vez de uma única instância ou o lote completo completo + +0:20:13.470,0:20:19.799 +agora quase todo mundo vai usar este mini lote selecionado uniformemente de forma aleatória + +0:20:19.799,0:20:23.009 +algumas pessoas usam com amostragem de reposição e algumas pessoas usam sem + +0:20:23.009,0:20:26.669 +com amostragem de reposição, mas as diferenças não são importantes para isso + +0:20:26.669,0:20:31.729 +propósitos você pode usar e há muitas vantagens em mini lotes, então + +0:20:31.729,0:20:35.220 +na verdade, existem algumas boas razões teóricas para não ser qualquer lote + +0:20:35.220,0:20:38.609 +mas as razões práticas são parte esmagadora dessas + +0:20:38.609,0:20:43.950 +razões são computacionais, fazemos amônia pode utilizar nosso hardware, digamos em + +0:20:43.950,0:20:47.489 +1% de eficiência ao treinar algumas das redes que usamos se tentarmos usar + +0:20:47.489,0:20:51.239 +instâncias únicas e obtemos a utilização mais eficiente do hardware + +0:20:51.239,0:20:55.979 +com tamanhos de lote muitas vezes na casa das centenas, se você estiver treinando no típico + +0:20:55.979,0:20:59.999 +Conjunto de dados ImageNet para, por exemplo, você não usa tamanhos de lote menores que + +0:20:59.999,0:21:08.429 +cerca de 64 para obter uma boa eficiência talvez possa descer para 32, mas outro importante + +0:21:08.429,0:21:13.080 +aplicação é treinamento distribuído e isso está realmente se tornando uma grande coisa, então + +0:21:13.080,0:21:17.309 +como foi mencionado antes que as pessoas pudessem treinar dias de ImageNet recentemente + +0:21:17.309,0:21:21.639 +disse que normalmente leva dois dias para treinar e não faz muito tempo que levava + +0:21:21.639,0:21:25.779 +em uma semana para treinar em apenas uma hora e o jeito que eles fizeram isso foi usando muito + +0:21:25.779,0:21:29.889 +grandes mini lotes e junto com o uso de grandes lotes, existem alguns truques + +0:21:29.889,0:21:34.059 +que você precisa usar para fazê-lo funcionar, provavelmente não é algo que você + +0:21:34.059,0:21:37.149 +cobriria uma palestra introdutória, então eu encorajo você a verificar esse artigo se + +0:21:37.149,0:21:40.409 +você está interessado é ImageNet em uma hora + +0:21:40.409,0:21:45.279 +deixa os autores do face book não me lembro do primeiro autor no momento como um lado + +0:21:45.279,0:21:51.459 +observe que existem algumas situações em que você precisa fazer a otimização completa do lote + +0:21:51.459,0:21:54.759 +não usar gradiente descendente nessa situação, não posso enfatizar o suficiente para + +0:21:54.759,0:21:59.950 +não use subida de gradiente se você tiver dados de lote completos de longe + +0:21:59.950,0:22:03.249 +método eficaz que é tipo plug-and-play que você não precisa pensar + +0:22:03.249,0:22:08.859 +é conhecido como l-bfgs é o acúmulo de 50 anos de pesquisa de otimização e + +0:22:08.859,0:22:12.519 +funciona muito bem a implementação do torch é muito boa + +0:22:12.519,0:22:17.379 +mas a implementação do Scipy causa algum código de filtragem que foi escrito há 15 anos + +0:22:17.379,0:22:23.440 +atrás, isso é praticamente à prova de balas, então porque eles eram aqueles, então isso é uma boa + +0:22:23.440,0:22:26.619 +pergunta classicamente você precisa usar o + +0:22:26.619,0:22:28.809 +conjunto de dados agora implementação do PyTorch na verdade + +0:22:28.809,0:22:34.209 +suporta o uso de mini bateria agora esta é uma área cinzenta em que há + +0:22:34.209,0:22:37.899 +realmente nenhuma teoria para apoiar o uso disso e pode funcionar bem para o seu + +0:22:37.899,0:22:43.839 +problema ou pode não, então pode valer a pena tentar, quero dizer, você quer usar seu + +0:22:43.839,0:22:49.929 +conjunto de dados inteiro para cada avaliação de gradiente ou provavelmente mais provável desde + +0:22:49.929,0:22:52.359 +é muito raramente você quer fazer isso provavelmente mais provavelmente você está resolvendo alguns + +0:22:52.359,0:22:56.889 +outro problema de otimização que não está treinando em sua rede, mas talvez + +0:22:56.889,0:23:01.869 +algum problema auxiliar relacionado e você precisa resolver um problema de otimização + +0:23:01.869,0:23:06.669 +sem essa estrutura de pontos de dados que não é verão não é uma soma de dados + +0:23:06.669,0:23:12.239 +pontos sim espero que tenha sido outra pergunta sim oh sim a pergunta foi + +0:23:12.239,0:23:16.869 +Yann recomendou que usássemos minilotes iguais ao tamanho do número de + +0:23:16.869,0:23:20.079 +classes que temos em nosso conjunto de dados por que é razoável essa era a questão + +0:23:20.079,0:23:23.889 +a resposta é que queremos que quaisquer vetores sejam representativos dos dados completos + +0:23:23.889,0:23:28.329 +set e tipicamente cada classe é bastante distinta das outras classes em seu + +0:23:28.329,0:23:33.490 +propriedades assim sobre como usar um minilote que contém em média + +0:23:33.490,0:23:36.850 +uma instância de cada classe, de fato, podemos impor isso explicitamente, embora + +0:23:36.850,0:23:39.820 +não é necessário ter um aproximadamente igual a esse + +0:23:39.820,0:23:44.590 +tamanho, podemos assumir que tem o tipo de estrutura de um gradiente de comida para que você + +0:23:44.590,0:23:49.870 +capturar muitas das correlações nos dados que você vê com o gradiente completo e + +0:23:49.870,0:23:54.279 +é um bom guia, especialmente se você estiver usando o treinamento na CPU onde você não está + +0:23:54.279,0:23:58.690 +muito limitado pela eficiência do hardware aqui ao treinar em energia + +0:23:58.690,0:24:05.080 +em um tamanho de lote de CPU não é crítico para a utilização de hardware, é um problema + +0:24:05.080,0:24:09.370 +dependente eu sempre recomendaria mini batching não acho que vale a pena tentar + +0:24:09.370,0:24:13.899 +tamanho um como ponto de partida, se você tentar obter pequenos ganhos, talvez seja + +0:24:13.899,0:24:19.779 +vale a pena explorar sim, havia outra pergunta, então no exemplo de recozimento, então + +0:24:19.779,0:24:24.760 +a questão era por que a paisagem perdida é tão instável e é isso + +0:24:24.760,0:24:31.600 +na verdade, algo que é uma representação muito realista de batidas de lei reais + +0:24:31.600,0:24:37.630 +códigos para redes neurais são incrivelmente no sentido de que eles têm um + +0:24:37.630,0:24:41.860 +muitas colinas e vales e isso é algo que é pesquisado ativamente + +0:24:41.860,0:24:47.140 +agora o que podemos dizer, por exemplo, é que há um número muito grande de boas + +0:24:47.140,0:24:52.720 +mínimo e assim por colinas e vales sabemos disso porque suas redes têm + +0:24:52.720,0:24:56.590 +este aspecto combinatório para eles você pode colher os olhos do amperímetro uma rede neural + +0:24:56.590,0:25:00.309 +deslocando todos os pesos ao redor e você pode entrar em seu trabalho, você saberá se + +0:25:00.309,0:25:04.750 +ele produz exatamente a mesma saída para qualquer tarefa que você esteja olhando com todos + +0:25:04.750,0:25:07.419 +esses pesos se movimentavam e essa correspondência essencialmente a um + +0:25:07.419,0:25:12.460 +localização diferente no espaço de parâmetros, dado que há um número exponencial + +0:25:12.460,0:25:16.270 +dessas possíveis maneiras de reorganizar os pesos para obter a mesma rede + +0:25:16.270,0:25:18.940 +você vai acabar com o espaço que é exponencial incrivelmente pontiagudo + +0:25:18.940,0:25:24.789 +número desses picos agora a razão pela qual esses mínimos locais aparecem que + +0:25:24.789,0:25:27.580 +é algo que ainda é uma pesquisa ativa, então não tenho certeza se posso lhe dar + +0:25:27.580,0:25:32.890 +uma ótima resposta lá, mas eles são definitivamente observados na prática e o que + +0:25:32.890,0:25:39.000 +Posso dizer que eles parecem ser um problema menor que nós + +0:25:39.090,0:25:42.810 +como perto de redes de última geração, então esses mínimos locais foram considerados + +0:25:42.810,0:25:47.940 +grandes problemas há 15 anos, mas tanto no momento em que as pessoas essencialmente nunca atingem + +0:25:47.940,0:25:52.350 +na prática ao usar o tipo de parâmetros recomendados e coisas como + +0:25:52.350,0:25:55.980 +que quando você usa lotes muito grandes você pode ter esses problemas, não é + +0:25:55.980,0:25:59.490 +mesmo claro que o baixo desempenho ao usar grandes lotes é ainda + +0:25:59.490,0:26:03.900 +atribuível a esses mínimos maiores a esses mínimos locais, então isso é sim para + +0:26:03.900,0:26:08.550 +pesquisa em andamento sim, o problema é que você não pode realmente ver essa estrutura local + +0:26:08.550,0:26:10.920 +porque estamos neste espaço de um milhão de dimensões, não é uma boa maneira de + +0:26:10.920,0:26:15.090 +veja então sim eu não sei se as pessoas podem ter explorado isso já eu não sou + +0:26:15.090,0:26:18.840 +familiarizado com documentos sobre isso, mas aposto que alguém olhou para isso, então você pode + +0:26:18.840,0:26:23.520 +quero pesquisar isso no Google, então muitos dos avanços no design de redes neurais + +0:26:23.520,0:26:27.420 +na verdade, reduzi essa irregularidade de várias maneiras, então isso faz parte do + +0:26:27.420,0:26:30.510 +razão pela qual não é mais considerado um grande problema se era + +0:26:30.510,0:26:35.960 +considerado um grande problema no passado, há outras perguntas sim, então é + +0:26:35.960,0:26:41.550 +é difícil de ver, mas há certas coisas que você pode fazer que tornamos o + +0:26:41.550,0:26:46.830 +picos e vales menores certamente e redimensionando algumas partes do sistema neural + +0:26:46.830,0:26:50.010 +rede você pode amplificar certas direções da curvatura em certas + +0:26:50.010,0:26:54.320 +direções podem ser esticadas e esmagadas o resíduo de inovação particular + +0:26:54.320,0:27:00.000 +conexões que foram mencionadas são muito fáceis de ver que suavizam + +0:27:00.000,0:27:03.600 +a perda, de fato, você pode desenhar duas linhas entre dois pontos no + +0:27:03.600,0:27:06.570 +espaço e você pode ver o que acontece ao longo dessa linha que é realmente a melhor maneira de + +0:27:06.570,0:27:10.170 +tenho uma visualização de milhões de espaços dimensionais, então eu o transformo em uma dimensão + +0:27:10.170,0:27:13.200 +e você pode ver que é muito melhor entre esses dois pontos + +0:27:13.200,0:27:17.370 +quaisquer que sejam os dois pontos que você escolher ao usar essas conexões residuais, estarei + +0:27:17.370,0:27:21.570 +falando tudo sobre esquivar ou mais tarde na palestra, então sim, espero que eu + +0:27:21.570,0:27:24.870 +responda a essa pergunta sem precisar perguntar novamente, mas veremos + +0:27:24.870,0:27:31.560 +obrigado qualquer outra pergunta sim, então l-bfgs excelente método é uma espécie de + +0:27:31.560,0:27:34.650 +constelação de pesquisadores de otimização que ainda usamos SGD + +0:27:34.650,0:27:40.470 +método inventado nos anos 60 ou antes ainda é o estado da arte, mas + +0:27:40.470,0:27:44.880 +houve alguma inovação, na verdade, apenas alguns anos depois, mas houve algumas + +0:27:44.880,0:27:49.180 +inovação desde a invenção do sed e uma dessas inovações é + +0:27:49.180,0:27:54.730 +e eu vou falar sobre outro mais tarde, então o impulso é um truque + +0:27:54.730,0:27:57.520 +que você deve usar sempre quando estiver usando estocástico + +0:27:57.520,0:28:00.880 +gradiente descendente vale a pena entrar nisso com um pouco de detalhes + +0:28:00.880,0:28:04.930 +muitas vezes você estará ajustando o parâmetro de impulso e sua rede e é + +0:28:04.930,0:28:09.340 +útil para entender o que está realmente fazendo quando você está ajustando + +0:28:09.340,0:28:15.970 +o problema com o impulso é muito mal compreendido e isso pode ser explicado + +0:28:15.970,0:28:18.760 +pelo fato de que na verdade existem três maneiras diferentes de escrever o momento que + +0:28:18.760,0:28:21.790 +parecem completamente diferentes, mas acabam sendo equivalentes, só vou + +0:28:21.790,0:28:25.120 +apresentar duas dessas maneiras porque a terceira maneira não é tão conhecida, mas é + +0:28:25.120,0:28:30.070 +na verdade na minha opinião a maneira correta de ver eu não falo sobre minha + +0:28:30.070,0:28:32.470 +pesquisa aqui, então vamos falar sobre como ele é realmente implementado no + +0:28:32.470,0:28:37.390 +pacotes que você irá usar e este primeiro formulário aqui é o que está realmente implementado + +0:28:37.390,0:28:42.040 +no PyTorch e em outro software que você usará aqui, mantemos duas variáveis + +0:28:42.040,0:28:47.650 +agora você verá muitos papéis usando notação diferente aqui P é o + +0:28:47.650,0:28:51.580 +notação usada na física para momento e é muito comum usá-la também como + +0:28:51.580,0:28:55.720 +a variável momentum ao falar sobre sed com momentum então estarei seguindo + +0:28:55.720,0:29:01.000 +essa convenção, então, em vez de ter uma única iteração, agora temos que Eretz P + +0:29:01.000,0:29:06.940 +e W e a cada passo atualizamos ambos e esta é uma atualização bastante simples, então o + +0:29:06.940,0:29:13.060 +A atualização de P envolve adicionar ao antigo P e em vez de adicionar exatamente ao antigo + +0:29:13.060,0:29:16.720 +P nós meio que amortecemos o antigo P nós o reduzimos multiplicando-o por uma constante que é + +0:29:16.720,0:29:21.310 +pior do que um, então reduza o antigo P e aqui estou usando β̂ como a constante + +0:29:21.310,0:29:24.880 +lá de modo que provavelmente seria 0,9 na prática uma pequena quantidade de amortecimento e + +0:29:24.880,0:29:32.650 +adicionamos a isso o novo gradiente, então P é uma espécie de buffer de gradiente acumulado + +0:29:32.650,0:29:38.170 +você pode pensar em onde novos gradientes entram em valor total e gradientes anteriores + +0:29:38.170,0:29:42.490 +são reduzidos em cada etapa por um certo fator geralmente 0,9 que costumava reduzir + +0:29:42.490,0:29:47.910 +reduzido de modo que o buffer tende a ser uma espécie de soma de gradientes e + +0:29:47.910,0:29:53.080 +é basicamente nós apenas modificamos isso para descida de duas etapas de gradiente de Custer passo a passo + +0:29:53.080,0:29:56.440 +usando este P em vez do gradiente negativo em vez do gradiente desculpe + +0:29:56.440,0:30:00.260 +usando P em vez do na atualização, pois a fórmula de duas linhas + +0:30:00.260,0:30:05.790 +pode ser melhor entender isso pelo segundo formulário que coloco abaixo, isso é + +0:30:05.790,0:30:09.600 +equivalente você tem um mapa do β com uma pequena transformação, então não é + +0:30:09.600,0:30:12.750 +exatamente o mesmo β entre os dois métodos, mas é praticamente o mesmo + +0:30:12.750,0:30:20.300 +pois na prática são essencialmente os mesmos até colher romanização e + +0:30:21.260,0:30:25.530 +este filme eu acho que talvez seja mais claro essa forma é chamada de bola pesada estocástica + +0:30:25.530,0:30:31.170 +e aqui nossa atualização ainda inclui o gradiente, mas também estamos + +0:30:31.170,0:30:40.020 +adicionando uma cópia multiplicada da direção passada em que viajamos agora o que faz + +0:30:40.020,0:30:43.320 +isso significa o que estamos realmente fazendo aqui, então não é muito difícil + +0:30:43.320,0:30:49.170 +para visualizar e vou usar uma visualização de um destilado + +0:30:49.170,0:30:52.710 +publicação você pode ver o vestido lá embaixo e eu discordo muito + +0:30:52.710,0:30:55.620 +do que eles falaram nesse documento, mas eu gosto das visualizações + +0:30:55.620,0:31:02.820 +então vamos usar had e eu vou explicar porque eu discordei de alguns cumprimentos mais tarde, mas é + +0:31:02.820,0:31:07.440 +bastante simples para que você possa pensar no momento como o processo físico e eu + +0:31:07.440,0:31:10.650 +mencionar aqueles de vocês que fizeram cursos introdutórios de física teria + +0:31:10.650,0:31:17.340 +cobriu isso, então o impulso é a propriedade de algo para continuar se movendo no + +0:31:17.340,0:31:21.330 +direção que está se movendo no momento certo se você estiver familiarizado com Newton + +0:31:21.330,0:31:24.240 +leis, as coisas querem continuar na direção em que estão indo e isso é + +0:31:24.240,0:31:28.860 +momento e quando você faz isso mapeando a física, o gradiente é uma espécie de + +0:31:28.860,0:31:34.020 +força que está empurrando você é alfabetizado que por esta analogia é uma bola pesada + +0:31:34.020,0:31:39.860 +está empurrando essa bola pesada em cada ponto, em vez de fazer drama + +0:31:39.860,0:31:44.030 +mudanças na direção em que viajamos a cada passo que é mostrado na esquerda + +0:31:44.030,0:31:48.480 +diagrama em vez de fazer essas mudanças dramáticas, vamos fazer uma espécie de + +0:31:48.480,0:31:51.480 +mudanças um pouco mais modestas, então quando percebemos que estamos indo no caminho errado + +0:31:51.480,0:31:55.740 +direção, meio que fazemos uma inversão de marcha em vez de colocar o freio de mão e + +0:31:55.740,0:31:59.440 +balançando se torna muito prático + +0:31:59.440,0:32:01.810 +problemas, isso lhe dá uma grande melhoria, então aqui você pode ver que está + +0:32:01.810,0:32:06.280 +chegando muito mais perto da solução no final dela com muito menos oscilação + +0:32:06.280,0:32:10.840 +e você pode ver essa oscilação, então é um fato da vida se você estiver usando + +0:32:10.840,0:32:14.650 +métodos do tipo gradiente descendente, então aqui falamos sobre o momento em cima do gradiente + +0:32:14.650,0:32:18.550 +descida na visualização você vai ter essa oscilação é apenas um + +0:32:18.550,0:32:22.240 +propriedade do gradiente descendente não há como se livrar dele sem modificar o + +0:32:22.240,0:32:27.490 +método e estamos destinados a eles até certo ponto amortece essa oscilação que eu tenho + +0:32:27.490,0:32:30.760 +outra visualização aqui que lhe dará uma intuição de como + +0:32:30.760,0:32:34.660 +este parâmetro β controla as coisas agora o Departamento destes para ser maior + +0:32:34.660,0:32:39.280 +que zero se for igual a zero você distr em gradiente descendente e tem que + +0:32:39.280,0:32:43.330 +ser menor que um caso contrário o Met tudo explode quando você começa + +0:32:43.330,0:32:45.970 +incluindo gradientes anteriores com cada vez mais peso ao longo do tempo, tem que ser + +0:32:45.970,0:32:54.070 +entre zero e um e os valores típicos variam de você sabe pequeno 0,25 até + +0:32:54.070,0:32:59.230 +como 0,99 então na prática você pode chegar bem perto de um e o que acontece é + +0:32:59.230,0:33:09.130 +os valores menores que resultam em você está mudando de direção mais rápido ok então em + +0:33:09.130,0:33:12.820 +este diagrama você pode ver à esquerda com o pequeno β você assim que você + +0:33:12.820,0:33:16.120 +aproxime-se da solução, você meio que muda de direção rapidamente e segue + +0:33:16.120,0:33:19.900 +em direção a uma solução quando você usa esses βs maiores, leva mais tempo para você + +0:33:19.900,0:33:23.530 +fazer esta curva dramática você pode pensar nisso como um carro com um raio de viragem ruim + +0:33:23.530,0:33:26.170 +leva muito tempo para contornar aquela esquina e seguir em direção + +0:33:26.170,0:33:31.180 +solução agora isso pode parecer uma coisa ruim, mas na prática isso + +0:33:31.180,0:33:35.110 +amortece significativamente as oscilações que você obtém da descida do gradiente e + +0:33:35.110,0:33:40.450 +essa é a boa propriedade disso agora em termos de prática, posso lhe dar algumas + +0:33:40.450,0:33:45.760 +orientação bastante clara aqui, você sempre quer usar o impulso é + +0:33:45.760,0:33:48.820 +muito difícil encontrar problemas onde na verdade não é benéfico até certo ponto + +0:33:48.820,0:33:52.960 +agora parte da razão para isso é que é apenas um parâmetro extra agora normalmente + +0:33:52.960,0:33:55.870 +quando você pega algum método e apenas adiciona mais parâmetros a ele, geralmente pode + +0:33:55.870,0:34:01.000 +encontrar algum valor desse parâmetro que nos torne um pouco melhor agora que é + +0:34:01.000,0:34:04.330 +às vezes é o caso aqui, mas muitas vezes essas melhorias do uso do impulso são + +0:34:04.330,0:34:08.810 +realmente bastante substancial e usar um valor de momento de ponto nove é + +0:34:08.810,0:34:13.610 +realmente um valor padrão usado no aprendizado de máquina com bastante frequência e muitas vezes em alguns + +0:34:13.610,0:34:19.010 +situações 0,99 pode ser melhor, então eu recomendaria tentar ambos os valores se você tiver + +0:34:19.010,0:34:24.770 +caso contrário, tente o ponto nove, mas eu tenho que fazer um aviso sobre a forma como o impulso é + +0:34:24.770,0:34:29.300 +declarado nesta expressão se você olhar com atenção quando aumentamos o + +0:34:29.300,0:34:36.440 +momento nós meio que aumentamos o tamanho do passo agora não é o tamanho do passo do + +0:34:36.440,0:34:39.380 +gradiente atual para que o gradiente atual seja incluído na etapa com o mesmo + +0:34:39.380,0:34:43.399 +pontos fortes, mas gradientes passados ​​são incluídos na etapa com uma maior + +0:34:43.399,0:34:48.290 +força quando você aumenta o momento agora quando você escreve o momento em outras formas + +0:34:48.290,0:34:53.179 +isso se torna muito mais óbvio, então esse tipo de empresa obstrui isso, mas o que você + +0:34:53.179,0:34:58.820 +geralmente deve fazer quando você altera o momento, você deseja alterá-lo para que + +0:34:58.820,0:35:04.310 +você tem o tamanho do seu passo dividido por um menos β é o seu novo tamanho do passo, então se + +0:35:04.310,0:35:07.790 +seu tamanho de passo antigo estava usando um certo B, você deseja mapeá-lo para essa equação + +0:35:07.790,0:35:11.690 +em seguida, mapeie-o de volta para obter o novo tamanho da etapa agora, isso pode ser uma mudança muito modesta + +0:35:11.690,0:35:16.400 +mas se você estiver indo do momento 0,9 para o momento 0,99, talvez seja necessário reduzir + +0:35:16.400,0:35:20.480 +sua taxa de aprendizado por um fator de 10 aproximadamente, então tenha cuidado com isso + +0:35:20.480,0:35:22.850 +você não pode esperar manter a mesma taxa de aprendizado e mudar o ritmo + +0:35:22.850,0:35:27.260 +parâmetro no trabalho do wallmart agora quero entrar em detalhes sobre o porquê + +0:35:27.260,0:35:31.880 +o momentum funciona é muito mal compreendido e a explicação que você verá nisso + +0:35:31.880,0:35:38.570 +Pós destilado é aceleração e isso certamente contribui para a + +0:35:38.570,0:35:44.380 +desempenho do momento agora a aceleração é um tópico sim se você tiver uma pergunta + +0:35:44.380,0:35:48.170 +a questão era se há uma grande diferença entre usar impulso e + +0:35:48.170,0:35:54.890 +usando um minilote de dois e há então o impulso tem vantagens para quando + +0:35:54.890,0:35:59.150 +usando gradiente descendente, bem como gradiente descendente estocástico, de fato + +0:35:59.150,0:36:03.110 +esta explicação de aceleração estava prestes a usar se aplica tanto no estocástico + +0:36:03.110,0:36:07.520 +e caso não estocástico, portanto, não importa o tamanho do lote que você usará + +0:36:07.520,0:36:13.100 +benefícios do momentum ainda são mostrados agora também tem benefícios no estocástico + +0:36:13.100,0:36:17.000 +caso também, que abordarei em um slide ou dois, então a resposta é que é bastante + +0:36:17.000,0:36:19.579 +distinto do tamanho do lote e você não deve completá-los + +0:36:19.579,0:36:22.459 +aprenda como realmente você deveria estar mudando sua taxa de aprendizado quando você + +0:36:22.459,0:36:26.239 +mude o tamanho do seu taco em vez de mudar o momento e para muito grandes + +0:36:26.239,0:36:30.380 +tamanhos de lote há uma relação clara entre a taxa de aprendizado e o tamanho do lote, mas + +0:36:30.380,0:36:34.729 +para tamanhos de lote pequenos, não está claro, por isso depende do problema de qualquer outro + +0:36:34.729,0:36:38.599 +perguntas antes de seguir em frente sim, sim, é apenas explodir, então é + +0:36:38.599,0:36:42.979 +na verdade, na interpretação da física, é a conservação de + +0:36:42.979,0:36:48.499 +momento seria exatamente igual a um agora isso não é bom porque se você estiver em + +0:36:48.499,0:36:51.890 +um mundo sem atrito, então você solta uma bola pesada em algum lugar que vai manter + +0:36:51.890,0:36:56.479 +movendo-se para sempre, não é uma coisa boa, então precisamos de um pouco de amortecimento e é aqui que + +0:36:56.479,0:37:01.069 +a interpretação da física falha, então você precisa de um pouco de amortecimento agora, agora você + +0:37:01.069,0:37:05.209 +pode imaginar se você usar um valor maior do que aquele que os gradientes anteriores obtêm + +0:37:05.209,0:37:09.410 +amplificado a cada passo, então, na verdade, o primeiro gradiente que você avalia em seu + +0:37:09.410,0:37:13.940 +rede não é conteúdo de informação relevante mais tarde na otimização, mas + +0:37:13.940,0:37:16.910 +se fosse maior que 1, ele dominaria a etapa que você está + +0:37:16.910,0:37:21.170 +usando isso responde sua pergunta sim ok quaisquer outras perguntas sobre + +0:37:21.170,0:37:26.359 +momento antes de seguirmos em frente eles são para um valor particular de β sim, é + +0:37:26.359,0:37:30.859 +estritamente equivalente, não é muito difícil você ser capaz de fazê-lo como + +0:37:30.859,0:37:38.359 +duas linhas se você tentar fazer a equivalência, não os licitantes são + +0:37:38.359,0:37:40.910 +não é bem o mesmo mas o γ é o mesmo é por isso que eu uso o mesmo + +0:37:40.910,0:37:45.319 +notação para isso oh sim, então é isso que eu mencionei sim, então quando você muda β + +0:37:45.319,0:37:48.349 +você deseja dimensionar sua taxa de aprendizado pela taxa de aprendizado dividida por um sobre + +0:37:48.349,0:37:52.369 +β então neste formulário não tenho certeza se ele aparece neste formulário pode ser um + +0:37:52.369,0:37:55.969 +erro mas acho que estou bem aqui acho que não está nessa fórmula mas sim + +0:37:55.969,0:37:59.269 +o que você definitivamente quando muda β você precisa mudar a taxa de aprendizado também + +0:37:59.269,0:38:09.300 +para manter as coisas equilibradas, sim, ou a forma média é provavelmente + +0:38:09.300,0:38:13.830 +não vale a pena passar por cima, mas você pode pensar nisso como o momento está basicamente mudando + +0:38:13.830,0:38:17.850 +o ponto em que você avalia o gradiente na empresa padrão, você avalia o + +0:38:17.850,0:38:22.230 +gradiente neste ponto W na forma de média interna você faz uma corrida + +0:38:22.230,0:38:25.890 +média dos pontos que você está avaliando o Grady Nutt e você + +0:38:25.890,0:38:30.630 +avaliar nesse ponto, então é basicamente em vez de calcular a média de gradientes para + +0:38:30.630,0:38:37.530 +pontos médios é sentido claro Jewell sim sim então aceleração agora isso é + +0:38:37.530,0:38:43.260 +algo que você pode passar a carreira inteira estudando e é um pouco mal + +0:38:43.260,0:38:47.070 +entendido agora se você tentar ler o trabalho original de Nesterov agora + +0:38:47.070,0:38:53.520 +Nesterov é meio que o avô da otimização moderna em praticamente metade + +0:38:53.520,0:38:56.460 +os métodos que usamos têm o nome dele até certo ponto, o que pode ser confuso + +0:38:56.460,0:39:01.740 +às vezes e nos anos 80 ele veio com essa formulação que ele não escreveu em + +0:39:01.740,0:39:04.650 +desta forma ele escreveu em outra forma que as pessoas perceberam um tempo depois + +0:39:04.650,0:39:09.450 +poderia ser escrito desta forma e sua análise também é muito opaca e + +0:39:09.450,0:39:15.590 +originalmente escrito em russo não ajuda não para entender infelizmente + +0:39:15.590,0:39:21.180 +aquelas pessoas legais que a NSA traduziu toda a literatura russa na época, então + +0:39:21.180,0:39:27.330 +para que tenhamos acesso a eles e, na verdade, é uma modificação muito pequena de + +0:39:27.330,0:39:31.890 +a etapa de impulso, mas acho que uma pequena modificação diminui o que é + +0:39:31.890,0:39:36.600 +realmente não é o mesmo método, o que posso dizer é com + +0:39:36.600,0:39:41.400 +Nesterov Swimmer momentum se você escolher cuidadosamente essas constantes, você pode + +0:39:41.400,0:39:46.050 +obter o que é conhecido como convergência acelerada agora isso não se aplica em + +0:39:46.050,0:39:49.560 +suas redes, mas para problemas convexos, não entrarei em detalhes de convexidade, mas + +0:39:49.560,0:39:52.230 +alguns de vocês podem saber o que isso significa, é uma estrutura simples, mas + +0:39:52.230,0:39:55.740 +problemas convexos é uma taxa de convergência radicalmente melhorada deste + +0:39:55.740,0:39:59.940 +aceleração, mas apenas para constantes cuidadosamente escolhidas e você realmente não pode + +0:39:59.940,0:40:03.030 +escolha-os cuidadosamente com antecedência para que você tenha que fazer uma pesquisa bastante grande + +0:40:03.030,0:40:05.640 +sobre seus parâmetros seus hiperparâmetros desculpe encontrar o certo + +0:40:05.640,0:40:10.710 +constantes para obter essa aceleração, o que posso dizer é que isso realmente ocorre para + +0:40:10.710,0:40:14.779 +quadráticos ao usar o momento regular e isso confunde muitas pessoas + +0:40:14.779,0:40:18.559 +então você verá muitas pessoas dizendo que o momentum é um método acelerado, é + +0:40:18.559,0:40:23.449 +animado apenas para quadráticas e mesmo assim é um pouco duvidoso que eu faria + +0:40:23.449,0:40:27.529 +não recomendo usá-lo para quadráticos, use gradientes conjugados ou alguns novos + +0:40:27.529,0:40:33.499 +métodos que têm sido desenvolvidos ao longo dos últimos anos e isso é + +0:40:33.499,0:40:36.919 +definitivamente um fator que contribui para o nosso impulso funciona tão bem na prática e + +0:40:36.919,0:40:42.499 +há definitivamente alguma aceleração acontecendo, mas essa aceleração é difícil + +0:40:42.499,0:40:46.669 +para perceber quando você tem gradientes estocásticos agora quando você olha para o que + +0:40:46.669,0:40:51.679 +faz barulho de trabalho de aceleração realmente mata e é difícil de acreditar + +0:40:51.679,0:40:55.549 +que é o principal fator que contribui para o desempenho, mas é certamente + +0:40:55.549,0:40:59.989 +lá e o post ainda que mencionei atributos ou o desempenho de + +0:40:59.989,0:41:02.689 +impulso para aceleração, mas eu não iria tão longe, mas é + +0:41:02.689,0:41:08.390 +definitivamente um fator contribuinte, mas provavelmente a prática e comprovável + +0:41:08.390,0:41:13.669 +razão pela qual a aceleração por que sabe desculpe por que o impulso ajuda é a suavização de ruído + +0:41:13.669,0:41:21.619 +e isso são gradientes de médias de momento muito intuitivos no sentido de que mantemos + +0:41:21.619,0:41:25.099 +esses gradientes de buffer de execução que usamos como uma etapa em vez de individual + +0:41:25.099,0:41:30.259 +gradientes isso é uma forma de média e acontece que quando você + +0:41:30.259,0:41:33.229 +use s para D sem momento para provar qualquer coisa sobre isso + +0:41:33.229,0:41:37.449 +você realmente tem que trabalhar com a média de todos os pontos que você visitou + +0:41:37.449,0:41:42.380 +você pode obter limites muito fracos no último ponto em que acabou, mas + +0:41:42.380,0:41:45.349 +realmente você tem que trabalhar com essa média de pontos e isso não é o ideal + +0:41:45.349,0:41:48.529 +como se nunca quiséssemos levar essa média na prática, é muito + +0:41:48.529,0:41:52.099 +ponderado com pontos que visitamos há muito tempo que podem ser irrelevantes + +0:41:52.099,0:41:55.159 +e, de fato, essa média não funciona muito bem na prática para + +0:41:55.159,0:41:59.150 +redes é realmente importante apenas para problemas convexos, mas mesmo assim é + +0:41:59.150,0:42:03.380 +necessário analisar s2d regular e um dos fatos notáveis ​​sobre momentum + +0:42:03.380,0:42:09.019 +é na verdade essa média não é mais teoricamente necessária tão essencialmente + +0:42:09.019,0:42:14.509 +impulso adiciona suavização de otimização de sonho que nos torna tão + +0:42:14.509,0:42:19.459 +o último ponto que você visita ainda é uma boa aproximação da solução com SGG + +0:42:19.459,0:42:23.329 +realmente você quer fazer a média de um monte de últimos pontos que você viu para + +0:42:23.329,0:42:26.700 +obter uma boa aproximação para a solução agora deixe-me ilustrar que + +0:42:26.700,0:42:31.190 +aqui então este é um exemplo muito típico do que acontece ao usar STD + +0:42:31.190,0:42:36.329 +STD no início você faz um grande progresso, o gradiente é essencialmente + +0:42:36.329,0:42:39.960 +quase o mesmo que o gradiente estocástico, então os primeiros passos que você faz + +0:42:39.960,0:42:44.490 +grande progresso em direção à solução, mas então você acaba nesta bola agora lembre-se aqui + +0:42:44.490,0:42:47.579 +esse é um vale que estamos descendo, então essa bola aqui é meio que o chão + +0:42:47.579,0:42:53.550 +do vale e você meio que salta neste chão e o mais comum + +0:42:53.550,0:42:56.579 +A solução para isso é que se você reduzir sua taxa de aprendizado, você se recuperará + +0:42:56.579,0:43:01.290 +mais lento não é exatamente uma ótima solução, mas é uma maneira de lidar com isso, mas quando você + +0:43:01.290,0:43:04.710 +use s para lidar com o impulso, você pode suavizar esse salto e + +0:43:04.710,0:43:08.160 +você meio que meio que dá uma volta agora o caminho nem sempre vai ser + +0:43:08.160,0:43:12.300 +este caminho de ladrilhos de saca-rolhas é realmente bastante aleatório, você pode balançar + +0:43:12.300,0:43:15.990 +esquerda e direita, mas quando eu semeei com 42, isso é o que se espalhou, então é isso + +0:43:15.990,0:43:20.790 +o que estou usando aqui, você normalmente obtém esse saca-rolhas, você obtém essa pontuação de cortiça + +0:43:20.790,0:43:24.660 +para este conjunto de parâmetros e sim, acho que esta é uma boa explicação, então alguns + +0:43:24.660,0:43:27.960 +combinação de aceleração e suavização de ruído é o motivo pelo qual o impulso funciona + +0:43:27.960,0:43:33.180 +oh sim sim então devo dizer que quando injetamos ruído aqui o gradiente pode não + +0:43:33.180,0:43:37.470 +mesmo ser a direção certa para viajar na verdade poderia ser na direção oposta + +0:43:37.470,0:43:40.800 +direção de onde você quer ir e é por isso que você meio que salta + +0:43:40.800,0:43:46.410 +o vale lá então na verdade o cinza você pode ver aqui que o primeiro passo com + +0:43:46.410,0:43:49.980 +O SUV é praticamente ortogonal ao nível estabelecido ali, porque é + +0:43:49.980,0:43:52.770 +um passo tão bom no início, mas uma vez que você desce mais, pode apontar + +0:43:52.770,0:44:00.300 +em praticamente qualquer direção vagamente em torno da solução, então ontem com + +0:44:00.300,0:44:03.540 +momento é atualmente o método de otimização de última geração para muitas máquinas + +0:44:03.540,0:44:08.730 +problemas de aprendizagem, então você provavelmente vai usá-lo em seu curso por muitos + +0:44:08.730,0:44:12.990 +problemas, mas houve algumas outras inovações ao longo dos anos e estas são + +0:44:12.990,0:44:16.829 +particularmente útil para problemas mal condicionados agora como mencionei + +0:44:16.829,0:44:19.770 +no início da palestra alguns problemas têm esse tipo de condição de poço + +0:44:19.770,0:44:22.530 +propriedade que não podemos realmente caracterizar para redes neurais, mas + +0:44:22.530,0:44:27.450 +pode medi-lo pelo teste de que se s para D funcionar, então está bem condicionado + +0:44:27.450,0:44:31.470 +eventualmente não funciona e se devo estar andando mal condicionado então + +0:44:31.470,0:44:34.410 +temos outros métodos que podemos manipular, podemos usar para lidar com isso em alguns + +0:44:34.410,0:44:39.690 +situações e estes geralmente são chamados de métodos adaptativos agora você precisa + +0:44:39.690,0:44:43.500 +tenha um pouco de cuidado porque o que você está adaptando para as pessoas na literatura usam + +0:44:43.500,0:44:51.780 +esta nomenclatura para adaptar as taxas de aprendizagem adaptando os parâmetros de momento, mas + +0:44:51.780,0:44:56.339 +em nossa situação, estamos falando de um tipo específico de adaptabilidade romana + +0:44:56.339,0:45:03.780 +adaptabilidade são as taxas de aprendizado individual agora o que quero dizer com isso, então no + +0:45:03.780,0:45:06.869 +simulação eu já mostrei uma descida de gradiente estocástica + +0:45:06.869,0:45:10.619 +Eu usei uma taxa de aprendizado global, quero dizer todas as taxas em sua rede + +0:45:10.619,0:45:16.800 +é atualizado usando uma equação com o mesmo γ agora γ pode variar ao longo + +0:45:16.800,0:45:21.720 +passo de tempo, então você usou γ K na notação, mas muitas vezes você usa um fixo + +0:45:21.720,0:45:26.310 +câmera por um bom tempo, mas para métodos adaptativos queremos adaptar um + +0:45:26.310,0:45:30.240 +taxa de aprendizagem para cada peso individualmente e queremos usar + +0:45:30.240,0:45:37.109 +informações que obtemos de gradientes para cada peso para adaptar isso, então isso parece + +0:45:37.109,0:45:39.900 +como a coisa óbvia a fazer e as pessoas têm tentado fazer com que essas coisas + +0:45:39.900,0:45:43.200 +funcionam há décadas e meio que nos deparamos com alguns métodos que funcionam e + +0:45:43.200,0:45:48.510 +alguns que não, mas eu quero fazer perguntas aqui se houver alguma + +0:45:48.510,0:45:53.040 +explicação necessária para que eu possa dizer que não está totalmente claro por que você precisa + +0:45:53.040,0:45:56.880 +faça isso direito se sua rede estiver bem condicionada você não precisa fazer isso + +0:45:56.880,0:46:01.349 +potencialmente, mas muitas vezes as redes que usamos na prática têm + +0:46:01.349,0:46:05.069 +estrutura em diferentes partes da rede, por exemplo, as primeiras partes + +0:46:05.069,0:46:10.619 +da sua rede neural convolucional podem ser camadas convolucionais muito rasas em + +0:46:10.619,0:46:14.849 +imagens grandes posteriormente na rede, você fará convoluções com + +0:46:14.849,0:46:18.359 +grande número de canais em imagens pequenas agora essas operações são muito + +0:46:18.359,0:46:21.150 +diferente e não há razão para acreditar que uma taxa de aprendizado que funciona + +0:46:21.150,0:46:26.310 +bem para um funcionaria bem para o outro e é por isso que a adaptação + +0:46:26.310,0:46:28.140 +taxas de aprendizagem podem ser úteis quaisquer perguntas aqui + +0:46:28.140,0:46:32.250 +sim, infelizmente não há uma boa definição para redes neurais que + +0:46:32.250,0:46:35.790 +não poderia medi-lo mesmo que houvesse uma boa definição, então vou usá-lo + +0:46:35.790,0:46:40.109 +em um sentido vago que realmente não funciona e é mal + +0:46:40.109,0:46:42.619 +condicionado sim, então no tipo de caso quadrático se + +0:46:45.830,0:46:51.380 +você se lembra que eu tenho uma definição explícita deste número de condição L sobre μ. + +0:46:51.380,0:46:55.910 +L sendo maximizado em valor μ sendo o menor valor próprio e sim o grande + +0:46:55.910,0:47:00.140 +desta lacuna entre o maior e o menor valor próprio, a pior condição + +0:47:00.140,0:47:03.320 +é isso não implica se na sua rede para que μ não exista em + +0:47:03.320,0:47:07.610 +suas redes L ainda tem algumas informações, mas eu não diria + +0:47:07.610,0:47:12.800 +é um fator determinante, há muita coisa acontecendo, então existem algumas maneiras de + +0:47:12.800,0:47:15.619 +sua aparência se comporta muito como problemas simples, mas existem outras maneiras de + +0:47:15.619,0:47:23.090 +nós meio que acenamos e dizemos que eles gostam deles sim, sim, sim, então para isso + +0:47:23.090,0:47:25.910 +rede particular esta é uma rede que na verdade não é muito ruim + +0:47:25.910,0:47:30.920 +condicionado já na verdade esse é um VDD 16 que é praticamente a melhor rede + +0:47:30.920,0:47:34.490 +método melhor rede quando você tinha um trem antes da invenção de certos + +0:47:34.490,0:47:37.369 +técnicas para melhorar o condicionamento, então isso é quase o melhor do primeiro + +0:47:37.369,0:47:40.910 +condição que você pode realmente obter e há muito da estrutura deste + +0:47:40.910,0:47:45.140 +rede é realmente definida por este condicionamento como nós dobramos o número + +0:47:45.140,0:47:48.680 +de canais após certas etapas, porque isso parece resultar em redes em um + +0:47:48.680,0:47:53.600 +condição do mundo em vez de qualquer outro motivo, mas é certamente o que você pode + +0:47:53.600,0:47:57.170 +dizer é que pesos muito leves a rede tem efeito muito grande no + +0:47:57.170,0:48:02.630 +produza essa última camada lá com se houver 4096 pesos nela, isso é um + +0:48:02.630,0:48:06.400 +número muito pequeno de brancos esta rede tem milhões de brancos acredito que aqueles + +0:48:06.400,0:48:10.640 +Os pesos 4096 têm um efeito muito forte na saída porque eles diretamente + +0:48:10.640,0:48:14.450 +ditar essa saída e, por esse motivo, você geralmente deseja usar + +0:48:14.450,0:48:19.190 +taxas de aprendizado para aqueles, enquanto sim pondera no início da rede alguns dos + +0:48:19.190,0:48:21.770 +eles podem ter um grande efeito, mas especialmente quando você inicializou + +0:48:21.770,0:48:25.910 +rede de aleatoriamente eles normalmente terão um efeito menor daqueles que + +0:48:25.910,0:48:29.840 +pesos anteriores e isso é muito ondulado e a razão é porque nós + +0:48:29.840,0:48:33.859 +realmente não entendo isso bem o suficiente para eu lhe dar uma precisão precisa + +0:48:33.859,0:48:41.270 +declaração aqui 120 milhões de pesos nesta rede, na verdade, sim, para que + +0:48:41.270,0:48:47.710 +última camada é como 4096 por 4096 matriz, então + +0:48:47.950,0:48:53.510 +sim ok qualquer outra pergunta sim sim eu recomendaria usá-los apenas quando + +0:48:53.510,0:48:59.120 +seu problema não tem uma estrutura que se decompõe em uma grande soma de + +0:48:59.120,0:49:04.880 +coisas semelhantes ok, sim, isso é um pouco difícil, mas funciona bem quando você + +0:49:04.880,0:49:09.830 +tem um objetivo que é uma soma onde cada termo da soma é vagamente + +0:49:09.830,0:49:14.990 +comparável, portanto, no aprendizado de máquina, cada subtermo nessa soma é uma perda de um + +0:49:14.990,0:49:18.290 +ponto de dados e estes têm estruturas muito semelhantes perdas individuais que é um + +0:49:18.290,0:49:21.080 +sentido de mão ondulada que eles têm estrutura muito semelhante porque é claro que cada + +0:49:21.080,0:49:25.220 +ponto de dados pode ser bem diferente, mas quando seu problema não tem um grande + +0:49:25.220,0:49:30.440 +sum como a parte principal de sua estrutura, então l-bfgs seria útil, essa é a + +0:49:30.440,0:49:35.840 +resposta geral duvido que você faça uso disso neste curso l-bfgs duvido que + +0:49:35.840,0:49:40.660 +pode ser muito útil para pequenas redes com as quais você pode experimentar + +0:49:40.660,0:49:44.720 +a rede leaner v ou algo que eu tenho certeza que você provavelmente usa neste curso + +0:49:44.720,0:49:51.230 +você poderia experimentar com l-bfgs provavelmente e ter algum sucesso lá + +0:49:51.230,0:49:58.670 +do tipo de técnicas fundamentais no treinamento moderno de sua rede é rmsprop + +0:49:58.670,0:50:03.680 +e eu vou falar sobre este ano agora em algum ponto do padrão + +0:50:03.680,0:50:07.640 +prática no campo da otimização está no tipo de pesquisa e otimização de + +0:50:07.640,0:50:10.640 +divergiram com o que as pessoas estavam realmente fazendo ao treinar redes neurais e + +0:50:10.640,0:50:14.150 +este suporte IMS foi uma espécie de ponto de ruptura onde todos nós saímos em diferentes + +0:50:14.150,0:50:19.820 +direções e este rmsprop é geralmente atribuído aos slides de Geoffrey Hinton + +0:50:19.820,0:50:23.380 +que ele então atribui a um artigo inédito de outra pessoa + +0:50:23.380,0:50:28.790 +o que é realmente insatisfatório estar citando slides de alguém em um artigo, mas + +0:50:28.790,0:50:34.400 +de qualquer forma, é um método que tem alguns, não tem provas por que funciona, mas + +0:50:34.400,0:50:38.050 +é semelhante aos métodos que você pode provar que funciona, então isso é pelo menos algo + +0:50:38.050,0:50:43.520 +e funciona muito bem na prática e é por isso que eu procuro se usarmos, então eu quero + +0:50:43.520,0:50:46.310 +para lhe dar esse tipo de introdução antes do que eu expliquei o que realmente + +0:50:46.310,0:50:51.020 +é e rmsprop significa propagação quadrática média da raiz + +0:50:51.020,0:50:54.579 +isso foi da época em que tudo que fazemos as redes de combustível nós + +0:50:54.579,0:50:58.690 +chamado propagação tal e tal como back prop, que agora chamamos de deep, então + +0:50:58.690,0:51:02.920 +provavelmente seria chamado de Armas Deep propyl algo se estivesse embutido agora e + +0:51:02.920,0:51:08.470 +é um pouco de modificação, então ainda é um algoritmo de linha, mas um pouco + +0:51:08.470,0:51:11.200 +um pouco diferente, então vou repassar esses termos com algum detalhe porque é + +0:51:11.200,0:51:19.450 +importante entender isso agora nós mantemos em torno desse buffer V agora isso é + +0:51:19.450,0:51:22.720 +não é um buffer de momento ok, então estamos usando uma notação diferente aqui que ele está fazendo + +0:51:22.720,0:51:27.069 +algo diferente e vou usar alguma notação de que algumas pessoas + +0:51:27.069,0:51:30.760 +realmente odeia, mas acho conveniente vou escrever o elemento sábio + +0:51:30.760,0:51:36.040 +quadrado de um vetor apenas elevando o vetor ao quadrado, isso não é realmente confuso + +0:51:36.040,0:51:40.390 +notadamente em quase todas as situações, mas é uma boa maneira de escrevê-lo, então aqui + +0:51:40.390,0:51:43.480 +Estou escrevendo o gradiente ao quadrado, quero dizer que você pega todos os elementos + +0:51:43.480,0:51:47.109 +esse vetor de milhão de elementos vetor ou o que quer que seja e quadrado cada elemento + +0:51:47.109,0:51:51.309 +individualmente, então esta atualização de vídeo é conhecida como um movimento exponencial + +0:51:51.309,0:51:55.480 +média eu tenho um rápido show de mãos que está familiarizado com exponencial + +0:51:55.480,0:51:59.890 +médias móveis eu quero saber se preciso falar sobre isso em um pouco mais parece + +0:51:59.890,0:52:03.270 +provavelmente é necessário explicá-lo com alguma profundidade, mas em exposição para uma média móvel + +0:52:03.270,0:52:08.020 +é uma maneira padrão que isso tem sido usado por muitas décadas em muitos campos + +0:52:08.020,0:52:14.650 +para manter uma média que são as quantidades que podem mudar ao longo do tempo ok + +0:52:14.650,0:52:19.630 +então, quando uma quantidade está mudando ao longo do tempo, precisamos colocar pesos maiores em novos + +0:52:19.630,0:52:24.210 +valores porque eles fornecem mais informações e uma maneira de fazer isso é + +0:52:24.210,0:52:30.700 +diminuir os valores antigos exponencialmente e quando você faz isso exponencialmente você quer dizer + +0:52:30.700,0:52:36.880 +que o peso de um valor antigo de digamos dez passos atrás terá peso alfa para + +0:52:36.880,0:52:41.109 +o dez em sua coisa, então é aí que o exponencial vem na saída de + +0:52:41.109,0:52:43.900 +o dez agora é que não está realmente na notação e na notação em cada + +0:52:43.900,0:52:49.390 +passo, basta baixar o vetor de passagem por esta constante alfa e como se você pudesse + +0:52:49.390,0:52:53.440 +imagine na sua cabeça coisas nesse buffer do buffer V que são muito antigas + +0:52:53.440,0:52:57.760 +cada passo eles são baixados pelo alpha em cada passo e assim como antes do alpha + +0:52:57.760,0:53:01.359 +aqui está algo entre zero e um, então não podemos usar valores maiores que um + +0:53:01.359,0:53:04.280 +lá, então isso irá amortecer todos os valores até que eles não mais + +0:53:04.280,0:53:08.180 +a média móvel exponencial, então este método mantém um movimento exponencial + +0:53:08.180,0:53:12.860 +média do segundo momento quero dizer segundo momento não central para que não + +0:53:12.860,0:53:18.920 +subtrair a média aqui a implementação do PyTorch tem um interruptor onde você + +0:53:18.920,0:53:22.370 +pode dizer para subtrair o jogo médio com isso, se você quiser, + +0:53:22.370,0:53:25.460 +provavelmente terá um desempenho muito semelhante na prática, há um artigo sobre o qual estou + +0:53:25.460,0:53:30.620 +com certeza, mas o método original não subtrai a média e usamos + +0:53:30.620,0:53:35.000 +este segundo momento para normalizar o gradiente e fazemos isso por elemento para + +0:53:35.000,0:53:39.560 +toda essa notação é por elemento cada elemento do gradiente é dividido + +0:53:39.560,0:53:43.310 +pela raiz quadrada da estimativa do segundo momento e se você acha que + +0:53:43.310,0:53:47.090 +essa raiz quadrada está realmente sendo o desvio padrão, embora isso seja + +0:53:47.090,0:53:50.990 +não é um momento central, então não é realmente o desvio padrão, é + +0:53:50.990,0:53:55.580 +útil pensar dessa maneira e o nome que você sabe que raiz significa quadrado é tipo + +0:53:55.580,0:54:03.590 +de aludir a essa divisão pela raiz da média dos quadrados e o + +0:54:03.590,0:54:07.820 +detalhe técnico importante aqui você tem que adicionar epsilon aqui para o irritante + +0:54:07.820,0:54:12.950 +problema que quando você divide 0 por 0 tudo quebra então você ocasionalmente + +0:54:12.950,0:54:16.310 +tem zeros em sua rede existem algumas situações em que faz um + +0:54:16.310,0:54:20.060 +diferença fora de quando seus gradientes zero, mas você absolutamente faz + +0:54:20.060,0:54:25.310 +precisa desse epsilon em seu método e você verá que este é um tema recorrente + +0:54:25.310,0:54:29.900 +desses métodos não adaptativos basicamente você tem que colocar um epsilon quando seu + +0:54:29.900,0:54:34.040 +a dividir algo apenas para evitar evitar dividir por 0 e normalmente isso + +0:54:34.040,0:54:38.690 +epsilon vai ficar perto da sua máquina Epsilon não sei se sim se você está + +0:54:38.690,0:54:41.750 +familiarizado com esse termo, mas é algo como 10 a menos 7 + +0:54:41.750,0:54:45.710 +às vezes 10 elevado a menos 8 algo dessa ordem então realmente só tem um pequeno + +0:54:45.710,0:54:49.790 +efeito sobre o valor antes de falar sobre porque esse método funciona quero falar + +0:54:49.790,0:54:53.150 +sobre o tipo mais recente de inovação em cima deste método e + +0:54:53.150,0:54:57.560 +esse é o método que realmente usamos na prática, então o rmsprop às vezes é + +0:54:57.560,0:55:03.170 +ainda uso, mas mais frequentemente usamos um método note átomo um átomo significa adaptativo + +0:55:03.170,0:55:10.790 +estimativa de momento, então Adam é rmsprop com impulso, então passei 20 minutos + +0:55:10.790,0:55:13.760 +dizendo que eu deveria usar o impulso, então vou dizer bem, você deve colocá-lo + +0:55:13.760,0:55:18.420 +no topo do rmsprop também há sempre de fazer isso pelo menos + +0:55:18.420,0:55:21.569 +meia dúzia nestes jornais para cada um deles, mas Adam é aquele que pegou + +0:55:21.569,0:55:25.770 +e a maneira como temos uma menção aqui é que na verdade convertemos a atualização do momento + +0:55:25.770,0:55:32.609 +para uma média móvel exponencial também agora isso pode parecer uma quantidade + +0:55:32.609,0:55:37.200 +atualização qualitativamente diferente, como fazer o impulso movendo a média de fato + +0:55:37.200,0:55:40.829 +o que estávamos fazendo antes é essencialmente equivalente a que você pode descobrir alguns + +0:55:40.829,0:55:44.490 +constantes onde você pode obter um método onde você usa uma exponencial em movimento + +0:55:44.490,0:55:47.760 +momento médio móvel que é equivalente ao mento regular, então + +0:55:47.760,0:55:50.460 +não pense nesse momento da média móvel como algo diferente + +0:55:50.460,0:55:54.000 +do que o seu impulso anterior, mas tem uma boa propriedade que você não precisa + +0:55:54.000,0:55:57.660 +alterar a taxa de aprendizado quando você mexer com o β aqui, o que eu acho que é um + +0:55:57.660,0:56:03.780 +grande melhoria, então sim, adicionamos impulso do gradiente e, assim como + +0:56:03.780,0:56:07.980 +antes com rmsprop temos essa média móvel exponencial do + +0:56:07.980,0:56:13.050 +gradiente quadrado em cima disso, basicamente apenas conectamos esse movimento + +0:56:13.050,0:56:17.010 +gradiente médio onde tínhamos o gradiente na atualização anterior, então é + +0:56:17.010,0:56:20.579 +não muito complicado agora, se você realmente ler o papel do átomo, verá um todo + +0:56:20.579,0:56:23.880 +monte de notação adicional, o algoritmo é como dez linhas + +0:56:23.880,0:56:28.859 +de três e isso é porque eles adicionam algo chamado correção de viés, isso é + +0:56:28.859,0:56:34.260 +na verdade não é necessário, mas vai ajudar um pouco, então todo mundo usa e tudo + +0:56:34.260,0:56:39.780 +faz é aumentar o valor desses parâmetros durante os estágios iniciais + +0:56:39.780,0:56:43.319 +de otimização e a razão pela qual você faz isso é porque você inicializa este + +0:56:43.319,0:56:48.150 +buffer de impulso em zero normalmente agora imagine seu inicializador inicial em zero + +0:56:48.150,0:56:52.440 +depois da primeira etapa, adicionaremos a isso um valor de 1 menos + +0:56:52.440,0:56:56.700 +β vezes o gradiente agora 1 menos β será tipicamente 0,1 porque nós + +0:56:56.700,0:57:00.599 +normalmente usa o ponto de momento 9, então, quando fazemos isso, nosso passo de gradiente é na verdade + +0:57:00.599,0:57:05.069 +usando uma taxa de aprendizado 10 vezes menor porque esse buffer de momento tem um décimo + +0:57:05.069,0:57:08.670 +de um gradiente nele e isso é indesejável, então todo o viés + +0:57:08.670,0:57:13.890 +correção faz é apenas multiplicar por 10 o passo nessas iterações iniciais e + +0:57:13.890,0:57:18.420 +a fórmula de correção de viés é basicamente a maneira correta de fazer isso para + +0:57:18.420,0:57:23.030 +resultar em uma etapa imparcial e imparcial aqui significa apenas a expectativa + +0:57:23.030,0:57:28.420 +do buffer de momento é o gradiente, então não é nada muito misterioso + +0:57:28.420,0:57:32.960 +sim, não pense nisso como uma grande adição, embora eu ache que + +0:57:32.960,0:57:37.190 +o papel do átomo foi o primeiro a usar a ação da bicicleta em um mainstream + +0:57:37.190,0:57:40.310 +método de otimização eu não sei se eles inventaram, mas certamente foi pioneiro + +0:57:40.310,0:57:44.990 +a correção de base para que esses métodos funcionem muito bem na prática, deixe-me apenas + +0:57:44.990,0:57:48.590 +dar-lhe uma comparação empírica comum aqui agora esta quadrática que estou usando é uma + +0:57:48.590,0:57:52.220 +diagonal quadrática, então é um pouco sombreado usar um método que funciona bem + +0:57:52.220,0:57:55.060 +em baixo ou quadrática em e diagonal quadrática, mas vou fazer isso de qualquer maneira + +0:57:55.060,0:58:00.320 +e você pode ver que a direção em que eles viajam é uma grande melhoria em relação ao SGD + +0:58:00.320,0:58:03.950 +então neste problema simplificado sut vai na direção errada no + +0:58:03.950,0:58:08.780 +começando onde rmsprop basicamente segue na direção certa agora o problema + +0:58:08.780,0:58:15.140 +é rmsprop sofre de ruído assim como sut regular sem ruído sofre para que você + +0:58:15.140,0:58:19.490 +obter esta situação em que meio que salta em torno do ideal de forma bastante significativa + +0:58:19.490,0:58:24.710 +e assim como com std com momento, quando adicionamos momento ao átomo, obtemos o mesmo + +0:58:24.710,0:58:29.210 +tipo de melhoria onde nós meio que saca-rolhas ou às vezes invertemos o saca-rolhas + +0:58:29.210,0:58:32.240 +em torno da solução esse tipo de coisa e isso leva você à solução + +0:58:32.240,0:58:35.960 +mais rápido e significa que o último ponto em que você está atualmente é uma boa estimativa + +0:58:35.960,0:58:39.370 +da solução não é uma estimativa barulhenta, mas é a melhor estimativa que você tem + +0:58:39.370,0:58:45.350 +então eu geralmente recomendaria usar um demova rmsprop e está atendendo ao caso + +0:58:45.350,0:58:50.750 +que para alguns problemas você simplesmente não pode usar o átomo SGD é necessário para o treinamento + +0:58:50.750,0:58:53.690 +algumas das redes neurais estavam usando nossos modelos de linguagem ou, digamos, nossa linguagem + +0:58:53.690,0:58:57.290 +modelos é necessário para treinar a rede então vou falar sobre + +0:58:57.290,0:59:03.580 +no final desta apresentação e é geralmente se eu tiver que + +0:59:07.490,0:59:10.670 +recomendar algo que você deve usar, você deve tentar de s a D com impulso + +0:59:10.670,0:59:14.690 +ou atom como você irá para métodos para otimizar suas redes, então há alguns + +0:59:14.690,0:59:19.430 +conselhos práticos para você, pessoalmente, odeio atom porque sou uma otimização + +0:59:19.430,0:59:24.920 +pesquisador e a teoria e seu artigo está errado, isso foi demonstrado + +0:59:24.920,0:59:29.360 +recentemente, então o método de fato não converge e você pode mostrar isso muito + +0:59:29.360,0:59:32.430 +problemas de teste simples, então uma das músicas mais pesadas + +0:59:32.430,0:59:35.820 +usar métodos no aprendizado de máquina moderno na verdade não funciona em muitos + +0:59:35.820,0:59:40.740 +situações isso é insatisfatório e é uma questão de pesquisa em andamento + +0:59:40.740,0:59:44.670 +da melhor maneira de corrigir isso, não acho que apenas modificando Adam um pouco + +0:59:44.670,0:59:47.160 +tentar consertá-lo é realmente a melhor solução, acho que tem um pouco mais + +0:59:47.160,0:59:52.620 +problemas fundamentais, mas não vou entrar em detalhes porque há um problema muito + +0:59:52.620,0:59:56.460 +problema prático sobre o qual eles precisam falar, embora Adam seja conhecido por às vezes + +0:59:56.460,0:00:01.140 +dar pior erro de generalização Acho que Yara falou em detalhes sobre + +0:00:01.140,0:00:08.730 +erro de generalização eu repasso isso então sim o erro de generalização é o + +0:00:08.730,0:00:14.100 +erro nos dados nos quais você não treinou seu modelo basicamente para que suas redes sejam + +0:00:14.100,0:00:17.370 +muito fortemente parametrizado e se você treiná-los para + +0:00:17.370,0:00:22.200 +dão perda zero nos dados em que você treinou, eles não darão perda zero em outros + +0:00:22.200,0:00:27.240 +dados aponta dados que nunca foram vistos antes e esse erro de generalização é + +0:00:27.240,0:00:32.310 +esse erro normalmente a melhor coisa que podemos fazer é minimizar a perda e os dados + +0:00:32.310,0:00:37.080 +temos, mas às vezes isso não é o ideal e acontece que quando você usa Adam é + +0:00:37.080,0:00:40.860 +bastante comum principalmente em problemas de imagem que você piora + +0:00:40.860,0:00:46.140 +erro de generalização do que quando você usa STD e as pessoas atribuem isso a um todo + +0:00:46.140,0:00:50.400 +monte de coisas diferentes, pode estar encontrando aqueles mínimos locais ruins que eu + +0:00:50.400,0:00:54.180 +mencionei anteriormente os que são menores, é uma pena que + +0:00:54.180,0:00:57.840 +quanto melhor seu método de otimização, maior a probabilidade de atingir esses pequenos + +0:00:57.840,0:01:02.460 +mínimos locais porque eles estão mais próximos de onde você está atualmente e é meio que + +0:01:02.460,0:01:06.510 +o objetivo de um método de otimização para encontrar o mínimo mais próximo em um sentido + +0:01:06.510,0:01:10.620 +esses métodos de otimização local que usamos, mas há um monte de outros + +0:01:10.620,0:01:16.950 +razões que você pode atribuir a ele menos barulho em Adam talvez possa ser + +0:01:16.950,0:01:20.100 +alguma estrutura talvez esses métodos onde você redimensiona + +0:01:20.100,0:01:23.070 +espaço como este tem esse problema fundamental onde eles dão o pior + +0:01:23.070,0:01:26.430 +generalização, não entendemos isso, mas é importante + +0:01:26.430,0:01:30.390 +sei que isso pode ser um problema ou em alguns casos não quer dizer que vai + +0:01:30.390,0:01:33.450 +dar um desempenho horrível, você ainda terá um neurônio muito bom que treina em + +0:01:33.450,0:01:37.200 +o final e o que posso dizer são os modelos de linguagem que treinamos + +0:01:37.200,0:01:41.890 +O Facebook usa métodos como o átomo ou o próprio átomo e eles + +0:01:41.890,0:01:46.960 +resultados muito melhores do que se você usar STD e há uma pequena coisa que + +0:01:46.960,0:01:51.490 +não vai afetá-lo, eu esperaria, mas com Adam você tem que manter esses + +0:01:51.490,0:01:56.410 +três buffers onde está sed você tem dois buffers de parâmetros isso não + +0:01:56.410,0:01:59.230 +importa, exceto quando você está treinando um modelo de 12 gigabytes e depois + +0:01:59.230,0:02:02.790 +realmente se torna um problema, acho que você não encontrará isso na prática + +0:02:02.790,0:02:06.280 +e certamente há um pouco de dúvida, então você precisa cortar dois parâmetros em vez de + +0:02:06.280,0:02:13.060 +um então sim, é um conselho prático, use Adam para prender você, mas em algo + +0:02:13.060,0:02:18.220 +isso também é sup também é uma coisa central oh desculpe tenho uma pergunta sim sim + +0:02:18.220,0:02:22.600 +você está absolutamente correto, mas normalmente eu acho que a pergunta foi + +0:02:22.600,0:02:28.000 +não estavam usando um pequeno épsilon no denominador resultar em explosão certamente + +0:02:28.000,0:02:32.440 +se o numerador for igual a aproximadamente um do que dividir por dez para o + +0:02:32.440,0:02:37.900 +sete negativo pode ser catastrófico e esta é uma pergunta legítima, mas + +0:02:37.900,0:02:45.250 +normalmente para que o buffer V tenha valores muito pequenos, o gradiente também + +0:02:45.250,0:02:48.340 +deve ter tido valores muito pequenos, você pode ver isso pela forma como o + +0:02:48.340,0:02:53.110 +as médias móveis exponenciais são atualizadas, então, na verdade, não é um problema prático + +0:02:53.110,0:02:56.860 +quando isso quando este V é incrivelmente pequeno o momento também é muito pequeno + +0:02:56.860,0:03:01.180 +e quando você está dividindo coisa pequena por coisa pequena você não explode oh + +0:03:01.180,0:03:08.050 +sim, então a pergunta é: devo comprar um SUV e um átomo separadamente ao mesmo tempo + +0:03:08.050,0:03:11.860 +tempo e apenas ver qual funciona melhor, na verdade, isso é praticamente o que fazemos + +0:03:11.860,0:03:14.620 +porque temos muitos computadores, temos apenas um corredor de computador que você precisa + +0:03:14.620,0:03:17.890 +um computador um átomo e ver qual funciona melhor, embora saibamos + +0:03:17.890,0:03:21.730 +da maioria dos problemas, qual é a melhor escolha para quaisquer problemas + +0:03:21.730,0:03:24.460 +você está trabalhando, talvez você possa tentar os dois, depende de quanto tempo vai durar + +0:03:24.460,0:03:27.940 +levar para treinar eu não tenho certeza exatamente o que você vai fazer em termos de + +0:03:27.940,0:03:31.150 +pratique neste curso sim, certamente maneira legítima de fazê-lo + +0:03:31.150,0:03:35.020 +na verdade, algumas pessoas usam SGD no início e depois mudam para átomo no + +0:03:35.020,0:03:39.430 +final que é certamente uma boa abordagem, apenas torna mais complicado e + +0:03:39.430,0:03:44.740 +complexidade deve ser evitada se possível sim, este é um daqueles problemas profundos sem resposta + +0:03:44.740,0:03:48.400 +perguntas, então a pergunta era: devemos 1s você lidar com muitas + +0:03:48.400,0:03:51.850 +inicializações e ver qual deles obtém a melhor solução não vou ajudar com o + +0:03:51.850,0:03:54.990 +irregularidade este é o caso da pequena rede neural + +0:03:54.990,0:03:59.160 +que você obterá soluções diferentes dependendo da sua inicialização agora + +0:03:59.160,0:04:02.369 +há uma propriedade notável do tipo de grandes redes que usamos no + +0:04:02.369,0:04:07.349 +momento e as redes de arte, desde que você use inicialização aleatória semelhante em + +0:04:07.349,0:04:11.400 +termos da variância de inicialização, você terminará praticamente em um + +0:04:11.400,0:04:16.380 +soluções de qualidade e isso não é bem entendido, então sim, é bastante + +0:04:16.380,0:04:19.319 +notável que sua rede neural pode treinar por trezentas épocas e você + +0:04:19.319,0:04:23.550 +acabar com a solução, o erro de teste é quase exatamente o mesmo que você + +0:04:23.550,0:04:26.220 +com uma inicialização completamente diferente, não entendemos isso + +0:04:26.220,0:04:31.800 +então, se você realmente precisar obter pequenos ganhos de desempenho, poderá obter + +0:04:31.800,0:04:36.150 +uma rede um pouco melhor executando vários e escolhendo o melhor e + +0:04:36.150,0:04:39.180 +parece que quanto maior sua rede e mais difícil seu problema, menos jogo você + +0:04:39.180,0:04:44.190 +obter de fazer isso sim, então a questão era que temos três buffers para cada + +0:04:44.190,0:04:49.470 +peso na resposta a resposta é sim, então essencialmente sim, basicamente na memória + +0:04:49.470,0:04:53.160 +temos uma cópia do mesmo tamanho que nossos dados de peso, então nosso peso será um + +0:04:53.160,0:04:55.920 +monte de tensores na memória, temos um monte separado de tensores que + +0:04:55.920,0:05:01.849 +nossos tensores de momento e temos um monte de outros tensores que são os + +0:05:01.849,0:05:09.960 +tensores de segundo momento, então sim, camadas de normalização, então isso é meio que + +0:05:09.960,0:05:14.369 +uma ideia inteligente por que tentar e sal por que tentar criar uma otimização melhor + +0:05:14.369,0:05:20.540 +algoritmo onde podemos criar uma rede melhor e essa é a ideia, então + +0:05:20.960,0:05:24.960 +as redes neurais modernas normalmente modificamos a rede adicionando + +0:05:24.960,0:05:32.280 +camadas entre as camadas existentes e o objetivo dessas camadas para melhorar a + +0:05:32.280,0:05:36.450 +desempenho de otimização e generalização da rede e a maneira + +0:05:36.450,0:05:39.059 +eles fazem isso pode acontecer de algumas maneiras diferentes, mas deixe-me dar-lhe uma + +0:05:39.059,0:05:44.430 +por exemplo, normalmente usaríamos o tipo padrão de combinações para que você + +0:05:44.430,0:05:48.930 +saiba que em suas redes modernas normalmente alternamos operações lineares + +0:05:48.930,0:05:52.319 +com operações não lineares e aqui chamo essas funções de ativação que + +0:05:52.319,0:05:56.069 +alterná-los linear não linear linear não linear o que poderíamos fazer é que podemos + +0:05:56.069,0:06:01.819 +coloque essas camadas de normalização entre a ordem linear não linear ou + +0:06:01.819,0:06:11.009 +antes, então, neste caso, estamos usando, por exemplo, este é o tipo de + +0:06:11.009,0:06:14.369 +estrutura que temos em redes reais onde temos uma recuperação de convolução que + +0:06:14.369,0:06:18.240 +convoluções ou operações lineares seguidas de normalização em lote, isso é + +0:06:18.240,0:06:20.789 +um tipo de normalização que detalharei em um minuto + +0:06:20.789,0:06:28.140 +seguido por riilu que é atualmente a função de ativação mais popular e nós + +0:06:28.140,0:06:31.230 +colocar essa mobilização entre essas camadas existentes e o que eu quero fazer + +0:06:31.230,0:06:35.940 +claro é que essas camadas de normalização afetam o fluxo de dados, de modo que + +0:06:35.940,0:06:39.150 +modificam os dados que estão fluindo, mas eles não alteram o poder do + +0:06:39.150,0:06:43.380 +rede no sentido de que você pode configurar os pesos na rede em + +0:06:43.380,0:06:46.769 +alguma forma que ainda dará qualquer saída que você teve em um desconhecido + +0:06:46.769,0:06:50.220 +rede com uma rede normalizada, então camadas de normalização que você não está fazendo + +0:06:50.220,0:06:53.670 +que funcionam mais poderosos, eles melhoram de outras maneiras normalmente quando adicionamos + +0:06:53.670,0:06:57.660 +coisas para uma rede neural o objetivo é torná-lo mais poderoso e sim isso + +0:06:57.660,0:07:01.740 +camada de normalização também pode ser após a ativação ou antes do linear ou + +0:07:01.740,0:07:05.009 +você sabe, porque isso envolve, fazemos isso para que muitos deles sejam + +0:07:05.009,0:07:11.400 +equivalente, mas qualquer dúvida aqui são esses bits sim sim, então isso é certamente + +0:07:11.400,0:07:16.140 +verdade, mas meio que queremos que o sensor de o2 real alguns dos dados, mas + +0:07:16.140,0:07:20.009 +não muito, mas também não é muito preciso porque as camadas de normalização + +0:07:20.009,0:07:24.989 +também pode dimensionar e enviar os dados e, portanto, não será necessariamente que, embora + +0:07:24.989,0:07:28.739 +é certamente na inicialização que eles não fazem esse dimensionamento no navio tão tipicamente + +0:07:28.739,0:07:32.460 +cortar metade dos dados e, de fato, se você tentar fazer uma análise teórica disso + +0:07:32.460,0:07:37.470 +é muito conveniente que corte metade dos dados para que a estrutura desta + +0:07:37.470,0:07:42.239 +camadas de normalização, todas elas fazem praticamente o mesmo tipo de operação e + +0:07:42.239,0:07:47.640 +quantos usam tipo de notação genérica aqui, então você deve imaginar que X é um + +0:07:47.640,0:07:54.930 +entrada para a camada de normalização e Y é uma saída e o que você faz é usar fazer um + +0:07:54.930,0:08:00.119 +operação de clareamento ou normalização onde você subtrai alguma estimativa de + +0:08:00.119,0:08:05.190 +a média dos dados e você divide por alguma estimativa do padrão + +0:08:05.190,0:08:10.259 +desvio e lembre-se antes que eu mencionei que queremos manter o + +0:08:10.259,0:08:12.630 +poder de representação da rede o mesmo + +0:08:12.630,0:08:17.430 +o que fazemos para garantir é que multiplicamos por um alfa e adicionamos uma desculpa na altura + +0:08:17.430,0:08:22.050 +multiplicado por um hey e adicionamos um B e isso é apenas para que a camada ainda possa + +0:08:22.050,0:08:27.120 +valores de saída em qualquer intervalo específico ou se sempre tivéssemos todas as camadas + +0:08:27.120,0:08:30.840 +saída em branco e dados que a rede não poderia produzir como um valor de milhão ou + +0:08:30.840,0:08:35.370 +algo assim não seria, só poderia fazer isso você sabe com muito em muito + +0:08:35.370,0:08:38.520 +casos raros porque isso seria muito pesado na cauda do normal + +0:08:38.520,0:08:41.850 +distribuição, então isso permite que nossas camadas essencialmente produzam coisas que são + +0:08:41.850,0:08:49.200 +o mesmo intervalo de antes e sim, então as camadas de normalização têm parâmetros e + +0:08:49.200,0:08:51.900 +na rede é um pouco mais complicado no sensor tem mais + +0:08:51.900,0:08:56.010 +parâmetros, normalmente é um número muito pequeno de parâmetros, como erro de arredondamento + +0:08:56.010,0:09:04.290 +em suas contagens de parâmetros de rede normalmente e sim, então a complexidade de + +0:09:04.290,0:09:06.840 +isso é ser meio vago sobre como você calcula a média e o padrão + +0:09:06.840,0:09:10.170 +desvio a razão pela qual estou fazendo isso é porque todos os métodos computam em um + +0:09:10.170,0:09:18.210 +maneira diferente e vou detalhar que em uma segunda pergunta sim pesa re lb oh é + +0:09:18.210,0:09:24.630 +apenas um parâmetro de deslocamento para que os dados possam ter uma média diferente de zero e queremos + +0:09:24.630,0:09:28.470 +atrasado para poder produzir saídas com uma média diferente de zero, então, se sempre apenas + +0:09:28.470,0:09:30.570 +subtrair a média que não poderia fazer isso + +0:09:30.570,0:09:34.950 +então ele apenas adiciona de volta o poder de representação à camada sim, então a pergunta + +0:09:34.950,0:09:40.110 +é que esses parâmetros a e B não invertem a normalização e e em + +0:09:40.110,0:09:44.730 +fato de que muitas vezes é o caso de eles fazerem algo semelhante, mas eles se movem + +0:09:44.730,0:09:48.750 +diferentes escalas de tempo, portanto, entre as etapas ou entre as avaliações, seu + +0:09:48.750,0:09:52.410 +rede, a média e a variância podem mudar substancialmente com base na + +0:09:52.410,0:09:55.320 +dados que você está alimentando, mas esses parâmetros a e B são bastante estáveis, eles se movem + +0:09:55.320,0:10:01.260 +lentamente à medida que você os aprende, porque eles são mais estáveis, isso é benéfico + +0:10:01.260,0:10:04.530 +propriedades e vou descrevê-las um pouco mais tarde, mas quero falar + +0:10:04.530,0:10:08.610 +sobre é exatamente como você normaliza os dados e é aí que a coisa crucial + +0:10:08.610,0:10:11.760 +então o primeiro desses métodos desenvolvidos foi a norma de lote e ele é este + +0:10:11.760,0:10:16.429 +tipo de normalização bizarra que eu acho uma ideia horrível + +0:10:16.429,0:10:22.460 +mas infelizmente funciona fantasticamente bem, então normaliza em lotes, então + +0:10:22.460,0:10:28.370 +queremos informações sobre um certo recall de canal para um convolucional + +0:10:28.370,0:10:32.000 +rede neural qual canal é uma dessas imagens latentes que você tem em + +0:10:32.000,0:10:34.610 +sua rede que, no meio da rede, você tem alguns dados que não + +0:10:34.610,0:10:37.070 +realmente se parece com uma imagem se você realmente olhar para ela, mas é em forma + +0:10:37.070,0:10:41.000 +como uma imagem de qualquer maneira e isso é um canal, então queremos calcular uma média + +0:10:41.000,0:10:47.239 +sobre isso neste canal, mas temos apenas uma pequena quantidade de dados que é + +0:10:47.239,0:10:51.380 +o que há neste canal basicamente altura vezes largura se for uma imagem + +0:10:51.380,0:10:56.000 +e acontece que não há dados suficientes para obter boas estimativas dessas médias e + +0:10:56.000,0:10:58.969 +parâmetros de variância, então o que o batchman faz é pegar uma média e variância + +0:10:58.969,0:11:05.570 +estimativa em todas as instâncias em seu mini-lote bastante simples + +0:11:05.570,0:11:09.890 +e é isso que divide o azul pela razão pela qual eu não gosto disso é não + +0:11:09.890,0:11:12.830 +descida de gradiente realmente estocástica se você estiver usando a normalização em lote + +0:11:12.830,0:11:19.429 +por isso quebra toda a teoria em que trabalho para viver, então prefiro algum outro + +0:11:19.429,0:11:24.409 +estratégias de normalização, de fato, logo após o Bacharelado e as pessoas + +0:11:24.409,0:11:27.409 +tentou normalizar através de todas as outras combinações possíveis de coisas que você pode + +0:11:27.409,0:11:31.699 +normalize por e acontece que os três que funcionam uma instância de camada e + +0:11:31.699,0:11:37.370 +norma de grupo e norma de camada aqui neste diagrama você fez a média de todos os + +0:11:37.370,0:11:43.820 +canais e em altura e largura agora isso não funciona em todos os problemas, então eu + +0:11:43.820,0:11:47.000 +só o recomendaria em um problema em que você sabe que ele já funciona e + +0:11:47.000,0:11:49.940 +esse é normalmente um problema em que as pessoas já o usam, então veja o que o + +0:11:49.940,0:11:53.989 +pessoas da rede estão usando se isso é uma boa ideia ou não vai depender do + +0:11:53.989,0:11:57.140 +a normalização de instâncias é algo muito usado na linguagem moderna + +0:11:57.140,0:12:03.380 +modelos e isso você não faz mais a média do lote, o que é bom, eu + +0:12:03.380,0:12:07.310 +não vamos falar sobre tanta profundidade eu realmente o que eu preferiria que você preferisse + +0:12:07.310,0:12:12.440 +que você usa na prática é a normalização de grupo, então aqui temos qual + +0:12:12.440,0:12:16.219 +através de um grupo de canais e este grupo está preso é escolhido arbitrariamente + +0:12:16.219,0:12:20.090 +e fixo no início, então normalmente nós apenas agrupamos as coisas numericamente para + +0:12:20.090,0:12:23.580 +canal 0 a 10 seria um canal de grupo que você conhece de 10 a 10 + +0:12:23.580,0:12:31.110 +20 certificando-se de não sobrepor, é claro, grupos disjuntos de canais e + +0:12:31.110,0:12:34.560 +o tamanho desses grupos é um parâmetro que você precisa ajustar, embora sempre + +0:12:34.560,0:12:39.150 +usar 32 na prática você pode ajustar isso e você só faz isso porque não há + +0:12:39.150,0:12:42.600 +informações suficientes em um único canal e usar todos os canais é demais + +0:12:42.600,0:12:46.170 +então você apenas usa algo no meio, é realmente uma ideia bastante simples e + +0:12:46.170,0:12:50.790 +acontece que essa norma de grupo geralmente funciona melhor do que o lote normal + +0:12:50.790,0:12:55.410 +problemas e isso significa que minha teoria HUD na qual trabalho ainda está equilibrada + +0:12:55.410,0:12:57.890 +então eu gosto disso, então por que a normalização ajuda isso é um + +0:13:02.190,0:13:06.330 +questão de disputa, de fato, nos últimos anos, vários artigos foram publicados + +0:13:06.330,0:13:08.790 +neste tópico infelizmente os jornais não concordaram + +0:13:08.790,0:13:13.590 +sobre por que funciona, todos eles têm explicações completamente separadas, mas há algumas + +0:13:13.590,0:13:16.260 +coisas que definitivamente estão acontecendo para que possamos moldá-las, podemos dizer com certeza + +0:13:16.260,0:13:24.120 +que a rede parece ser mais fácil de otimizar, então quero dizer que você pode usar + +0:13:24.120,0:13:28.140 +maiores taxas de aprendizado melhor em uma rede de melhor condição você pode usar maiores + +0:13:28.140,0:13:31.590 +taxas de aprendizagem e, portanto, obter uma convergência mais rápida, de modo que parece ser o + +0:13:31.590,0:13:35.030 +caso quando você usa camadas de normalização outro fator que é um pouco + +0:13:38.070,0:13:39.989 +contestado, mas acho que está razoavelmente bem estabelecido + +0:13:39.989,0:13:44.489 +você obtém ruído nos dados que passam pela sua rede quando usa + +0:13:44.489,0:13:49.940 +normalização na vagina e esse barulho vem de outras instâncias no bash + +0:13:49.940,0:13:53.969 +porque é aleatório o que eu gosto, as instâncias estão no seu lote quando você + +0:13:53.969,0:13:57.239 +calcule a média usando aquelas outras instâncias que a média é barulhenta e isso + +0:13:57.239,0:14:01.469 +ruído é então adicionado ou subtraído do seu peso, então quando você faz o + +0:14:01.469,0:14:06.050 +operação de normalização, então esse ruído está realmente ajudando + +0:14:06.050,0:14:11.790 +desempenho de generalização em sua rede agora tem havido muitos + +0:14:11.790,0:14:15.180 +artigos sobre injeção de ruído na internet funcionam para ajudar na generalização, então não é tão + +0:14:15.180,0:14:20.370 +uma ideia maluca de que esse barulho pode estar ajudando e em termos práticos + +0:14:20.370,0:14:24.030 +consideração esta normalização torna a inicialização de peso que você usa um + +0:14:24.030,0:14:28.260 +muito menos importante, costumava ser uma espécie de arte negra selecionar a inicialização + +0:14:28.260,0:14:32.460 +sua nova sua rede e as pessoas que realmente bom motivo é muitas vezes foi apenas + +0:14:32.460,0:14:35.340 +porque eles são muito bons em alterar sua inicialização e isso é apenas + +0:14:35.340,0:14:39.540 +menos o caso agora quando usamos camadas de normalização e também fornece a + +0:14:39.540,0:14:45.930 +benefício se você puder agrupar camadas com impunidade, então, novamente, costumava + +0:14:45.930,0:14:49.050 +ser a situação que se você apenas conectar duas maneiras possíveis em seu + +0:14:49.050,0:14:52.740 +provavelmente não funcionaria agora que usamos camadas de normalização + +0:14:52.740,0:14:57.900 +provavelmente funcionará e mesmo que seja uma ideia horrível e isso estimulou um + +0:14:57.900,0:15:02.310 +todo o campo de pesquisa de arquitetura automatizada, onde eles simplesmente se acalmam aleatoriamente + +0:15:02.310,0:15:05.940 +construir blocos juntos e tentar milhares deles e ver o que funciona e + +0:15:05.940,0:15:09.540 +que realmente não era possível antes porque isso normalmente resultaria em um + +0:15:09.540,0:15:14.010 +Rede mal condicionada que você não conseguiu treinar e com normalização normalmente + +0:15:14.010,0:15:19.590 +você pode treinar algumas considerações práticas para que o bacharel em + +0:15:19.590,0:15:23.310 +papel uma das razões pelas quais não foi inventado antes é o tipo de + +0:15:23.310,0:15:27.480 +coisa não óbvia que você tem que voltar propagar através do cálculo do + +0:15:27.480,0:15:32.160 +média e desvio padrão se você não fizer isso tudo explode agora você + +0:15:32.160,0:15:35.190 +pode ter que fazer isso sozinho, pois será implementado na implementação + +0:15:35.190,0:15:42.000 +que você usa oh sim, então eu não tenho experiência para responder que eu sinto + +0:15:42.000,0:15:45.060 +às vezes é apenas um método patenteado de animais de estimação, como as pessoas gostam + +0:15:45.060,0:15:49.710 +camadas em ternos normalmente esse campo mais e de fato uma boa norma se você é + +0:15:49.710,0:15:53.640 +apenas o tamanho do grupo cobre os dois, então eu teria certeza de que você provavelmente poderia + +0:15:53.640,0:15:56.640 +obter o mesmo desempenho usando a norma do grupo com um determinado tamanho de grupo escolhido + +0:15:56.640,0:16:00.980 +com cuidado sim, a escolha do nacional afeta + +0:16:00.980,0:16:06.720 +paralelização para que a implementação do zinco em sua biblioteca de computador ou seu + +0:16:06.720,0:16:10.380 +A biblioteca da CPU é bastante eficiente para cada um deles, mas é complicado quando + +0:16:10.380,0:16:14.820 +você está espalhando sua computação entre máquinas e você meio que tem que + +0:16:14.820,0:16:18.630 +sincronizar essas essas coisas e a norma do lote é um pouco difícil + +0:16:18.630,0:16:23.790 +porque isso significaria que você precisa calcular uma média em todas as máquinas + +0:16:23.790,0:16:27.540 +e agregador, enquanto se você estiver usando a norma do grupo, todas as instâncias estarão em um + +0:16:27.540,0:16:30.450 +máquina diferente, você pode calcular completamente a norma, então em todos + +0:16:30.450,0:16:34.350 +os outros três é normalização separada para cada instância + +0:16:34.350,0:16:37.560 +não depende das outras instâncias no lote, então é melhor quando você está + +0:16:37.560,0:16:40.570 +distribuindo é quando as pessoas usam a norma de lote em um cluster + +0:16:40.570,0:16:45.100 +eles realmente não sincronizam as estatísticas, o que o torna ainda menos parecido com o SGD + +0:16:45.100,0:16:51.250 +e me deixa ainda mais irritado então o que já era + +0:16:51.250,0:16:57.610 +sim sim Bacharel basicamente tem muito impulso não no sentido de otimização + +0:16:57.610,0:17:01.300 +mas no sentido da mente das pessoas, é muito usado por esse motivo + +0:17:01.300,0:17:05.860 +mas eu recomendaria a norma do grupo e há uma espécie de técnica + +0:17:05.860,0:17:09.760 +dados com norma de lote, você não deseja calcular esses valores médios e padrão + +0:17:09.760,0:17:14.950 +desvios em lotes durante o tempo de avaliação por tempo de avaliação quero dizer quando você + +0:17:14.950,0:17:20.170 +realmente executa sua rede no conjunto de dados de teste ou nós a usamos no mundo real + +0:17:20.170,0:17:24.370 +para alguns aplicativos, normalmente é nessas situações que você não tem lotes + +0:17:24.370,0:17:29.050 +mais lotes ou mais para treinar coisas, então você precisa de alguma substituição em + +0:17:29.050,0:17:33.100 +nesse caso, você pode calcular uma média móvel exponencial como falamos antes + +0:17:33.100,0:17:37.930 +e EMA desses desvios médios e padrão, você pode pensar por que + +0:17:37.930,0:17:41.260 +não usamos um EMA na implementação da norma de lote a resposta + +0:17:41.260,0:17:44.860 +é porque não funciona, mas parece uma ideia muito razoável e + +0:17:44.860,0:17:48.880 +as pessoas exploraram isso e bastante profundidade, mas não funciona oh sim + +0:17:48.880,0:17:52.900 +isso é bastante crucial, então as pessoas tentaram normalizar as coisas no sistema neural + +0:17:52.900,0:17:55.480 +redes antes de uma norma de lote ser inventada, mas eles sempre fizeram o + +0:17:55.480,0:17:59.380 +erro de não voltar a saltar pela média e desvio padrão e o + +0:17:59.380,0:18:02.290 +razão pela qual eles não fizeram isso é porque a matemática é realmente complicada e se + +0:18:02.290,0:18:05.650 +você tenta implementá-lo sozinho, provavelmente estará errado agora que temos torta + +0:18:05.650,0:18:09.460 +gráficos que calculam gradientes corretamente para você em todas as situações que você + +0:18:09.460,0:18:12.850 +poderia realmente fazer isso na prática e há apenas um pouco, mas apenas um + +0:18:12.850,0:18:16.780 +um pouco porque é surpreendentemente difícil, sim, então a questão é + +0:18:16.780,0:18:21.070 +há uma diferença se aplicarmos a normalização antes depois do que + +0:18:21.070,0:18:25.690 +não linearidade e a resposta é que haverá uma pequena diferença na + +0:18:25.690,0:18:28.930 +desempenho da sua rede agora não posso dizer qual é melhor porque + +0:18:28.930,0:18:32.110 +aparece em alguma situação funciona um pouco melhor em outras situações + +0:18:32.110,0:18:35.350 +o outro funciona melhor o que posso te dizer é como eu desenho aqui é + +0:18:35.350,0:18:39.100 +o que é usado na implementação PyTorch do ResNet e mais + +0:18:39.100,0:18:43.330 +implementações ressonantes, então provavelmente é quase tão bom quanto você pode obter I + +0:18:43.330,0:18:49.270 +acho que usaria a outra forma se fosse melhor e certamente é problema + +0:18:49.270,0:18:51.460 +dependia isso é mais uma daquelas coisas onde talvez o + +0:18:51.460,0:18:55.420 +nenhuma resposta correta como você faz isso e é apenas aleatório o que funciona melhor eu não + +0:18:55.420,0:19:03.190 +sei sim sim quaisquer outras perguntas sobre isso antes de passar para o que você precisa + +0:19:03.190,0:19:06.850 +mais dados para obter estimativas precisas da média e do desvio padrão + +0:19:06.850,0:19:10.570 +pergunta era por que é uma boa ideia calculá-lo em vários canais + +0:19:10.570,0:19:13.450 +em vez de um único canal e sim, é porque você só tem mais dados para + +0:19:13.450,0:19:17.800 +fazer uma estimativa melhor, mas você quer ter cuidado para não ter muitos dados + +0:19:17.800,0:19:21.130 +nisso porque então você não percebe o ruído e grava que o ruído é + +0:19:21.130,0:19:25.300 +realmente útil, então basicamente o tamanho do grupo na norma do grupo é apenas ajustar o + +0:19:25.300,0:19:28.870 +quantidade de ruído que temos basicamente a questão era como isso está relacionado + +0:19:28.870,0:19:32.950 +convoluções de grupo, tudo isso foi iniciado antes que boas convoluções fossem + +0:19:32.950,0:19:38.260 +usado certamente tem alguma interação com convoluções de grupo se você usá-los + +0:19:38.260,0:19:41.920 +e então você quer ter um pouco de cuidado aí eu não sei exatamente o que + +0:19:41.920,0:19:44.800 +a coisa correta a fazer é nesses casos, mas posso dizer que eles definitivamente + +0:19:44.800,0:19:48.610 +use a normalização nessas situações provavelmente mais de Batchelor do que de grupo + +0:19:48.610,0:19:53.260 +normal por causa do impulso que mencionei, é apenas mais popular vaginal sim, então + +0:19:53.260,0:19:56.890 +a questão é se alguma vez usamos nossas instâncias Beck do mini-lote em grupo + +0:19:56.890,0:20:00.310 +norma ou é sempre apenas uma única instância, sempre usamos apenas uma única + +0:20:00.310,0:20:04.450 +exemplo, porque há tantos benefícios que é muito mais simples em + +0:20:04.450,0:20:08.469 +implementação e, em teoria, para fazer isso, talvez você possa obter alguma melhoria + +0:20:08.469,0:20:11.530 +que na verdade eu aposto que há um jornal que faz isso em algum lugar porque eles + +0:20:11.530,0:20:15.190 +tentei ter alguma combinação disso na prática, suspeito se funcionou bem + +0:20:15.190,0:20:19.450 +provavelmente estaríamos usando, então provavelmente não funciona bem sob o + +0:20:19.450,0:20:24.370 +morte da otimização eu queria colocar algo um pouco interessante + +0:20:24.370,0:20:27.610 +porque todos vocês assistiram a uma palestra bastante densa, então isso + +0:20:27.610,0:20:31.870 +é algo que eu tenho trabalhado um pouco, eu pensei que você + +0:20:31.870,0:20:36.580 +pode achar interessante, então você pode ter visto o quadrinho xkcd aqui que eu + +0:20:36.580,0:20:42.790 +modificado, nem sempre é assim, é meio que o que faz tão + +0:20:42.790,0:20:46.270 +às vezes podemos simplesmente invadir um campo que não sabemos nada sobre isso e melhorar + +0:20:46.270,0:20:50.469 +como eles estão fazendo isso, embora você tenha que ter um pouco de cuidado para + +0:20:50.469,0:20:53.560 +o problema sobre o qual quero falar é aquele jovem que acho que mencionei brevemente em + +0:20:53.560,0:20:58.530 +a primeira palestra, mas quero entrar em detalhes, é a reconstrução de ressonância magnética + +0:20:58.530,0:21:04.639 +agora, no problema de reconstrução de ressonância magnética, pegamos dados brutos de uma máquina de ressonância magnética + +0:21:04.639,0:21:08.540 +máquina de imagem médica, pegamos dados brutos dessa máquina e reconstruímos um + +0:21:08.540,0:21:12.530 +imagem e há algum pipeline de um algoritmo no meio que + +0:21:12.530,0:21:17.900 +produz a imagem e o objetivo basicamente aqui é substituir 30 anos de + +0:21:17.900,0:21:21.020 +pesquise com qual algoritmo eles devem usar com redes neurais + +0:21:21.020,0:21:27.949 +porque é para isso que serei pago para fazer e vou dar-lhe um pouco de detalhe + +0:21:27.949,0:21:31.810 +então essas máquinas de ressonância magnética capturam dados no que é conhecido como domínio de Fourier I + +0:21:31.810,0:21:34.909 +sei que muitos de vocês fizeram processamento de sinal alguns de vocês podem não ter ideia + +0:21:34.909,0:21:42.070 +o que é isso e você não precisa entendê-lo para este problema oh sim + +0:21:44.770,0:21:49.639 +sim, então você pode ter visto o domínio adicional em um caso dimensional + +0:21:49.639,0:21:54.710 +então, para redes neurais, desculpe pela reconstrução de ressonância magnética, temos duas dimensões + +0:21:54.710,0:21:58.340 +Domínio de Fourier, o que você precisa saber é que é um mapeamento linear para obter + +0:21:58.340,0:22:02.389 +do domínio fluido para o domínio da imagem é apenas linear e muito eficiente + +0:22:02.389,0:22:06.350 +para fazer esse mapeamento leva literalmente milissegundos, não importa o tamanho do seu + +0:22:06.350,0:22:09.980 +imagens em computadores modernos tão lineares e fáceis de converter entre + +0:22:09.980,0:22:15.619 +os dois e as máquinas de ressonância magnética realmente capturam linhas ou colunas deste + +0:22:15.619,0:22:20.540 +Domínio de Fourier como amostras, eles são chamados de amostra na literatura, então cada vez + +0:22:20.540,0:22:25.280 +a máquina calcula uma amostra que é a cada poucos milissegundos ela recebe um papel + +0:22:25.280,0:22:28.940 +coluna desta imagem e isso é, na verdade, tecnicamente um valor complexo + +0:22:28.940,0:22:33.380 +imagem, mas isso não importa para minha discussão, então você pode imaginar que é + +0:22:33.380,0:22:38.300 +apenas uma imagem de dois canais se você imaginar um canal real e imaginário apenas pense + +0:22:38.300,0:22:42.830 +deles como canais de cores, o problema que queremos resolver é + +0:22:42.830,0:22:48.800 +acelerar a aceleração de MRI aqui é no sentido de mais rápido, então queremos executar + +0:22:48.800,0:22:53.830 +as máquinas mais rapidamente e produzem imagens de qualidade idêntica + +0:22:55.400,0:23:00.050 +e uma maneira de fazer isso da maneira mais bem-sucedida até agora é simplesmente não + +0:23:00.050,0:23:05.540 +capturando todas as colunas, apenas pulamos algumas aleatoriamente, é útil em + +0:23:05.540,0:23:09.320 +prática para também capturar algumas das colunas do meio, elas contêm + +0:23:09.320,0:23:14.150 +muita informação, mas fora do meio nós apenas capturamos aleatoriamente e + +0:23:14.150,0:23:16.699 +não pode mais usar uma boa operação linear + +0:23:16.699,0:23:20.270 +esse diagrama à direita é a saída dessa operação linear que mencionei + +0:23:20.270,0:23:23.810 +aplicado a esses dados para que não seja útil à Apple, eles apenas fazem algo + +0:23:23.810,0:23:27.100 +um pouco mais inteligente qualquer pergunta sobre isso antes de seguir em frente + +0:23:27.100,0:23:35.030 +são dimensões de frequência e fase, então, neste caso em particular, estou + +0:23:35.030,0:23:38.510 +certifique-se que neste diagrama uma das dimensões é frequência e uma é fase e o + +0:23:38.510,0:23:44.390 +valor é a magnitude de uma onda senoidal com essa frequência e fase, então se você + +0:23:44.390,0:23:48.980 +some todas as ondas senoidais acene-as com a frequência oh então com o + +0:23:48.980,0:23:54.620 +peso nesta imagem você obtém a imagem original, então é um pouco + +0:23:54.620,0:23:58.429 +mais complicado porque é em duas dimensões e as ondas senoidais que você tem + +0:23:58.429,0:24:02.030 +tenha um pouco de cuidado, mas é basicamente apenas cada pixel é a magnitude de um + +0:24:02.030,0:24:06.230 +onda senoidal ou se você quiser comparar com uma analogia 1d + +0:24:06.230,0:24:11.960 +você terá apenas frequências, então a intensidade do pixel é a força disso + +0:24:11.960,0:24:16.580 +frequência se você tiver uma nota musical diga uma nota de piano com um C maior como uma das + +0:24:16.580,0:24:19.340 +as frequências que seriam de um pixel esta imagem seria o C maior + +0:24:19.340,0:24:24.140 +frequência e outro pode ser menor ou algo assim e a magnitude + +0:24:24.140,0:24:28.370 +disso é o quão forte eles pressionam a tecla no piano para que você tenha frequência + +0:24:28.370,0:24:34.370 +informação sim para que o vídeo não funcione foi um dos maiores + +0:24:34.370,0:24:38.750 +avanços na matemática de Ameaças por muito tempo foi o + +0:24:38.750,0:24:41.690 +invenção do sensoriamento comprimido Tenho certeza que alguns de vocês já ouviram falar + +0:24:41.690,0:24:45.710 +sentindo uma mão levantada de mãos comprimidas sentindo sim alguns de vocês + +0:24:45.710,0:24:48.980 +especialmente o trabalho nas ciências matemáticas estaria ciente disso + +0:24:48.980,0:24:53.330 +basicamente há este jornal político fenomenal que mostrou que nós + +0:24:53.330,0:24:57.770 +poderia, em teoria, obter uma reconstrução perfeita a partir desses subamostrados + +0:24:57.770,0:25:02.080 +medições e tivemos alguns requisitos para que isso funcionasse + +0:25:02.080,0:25:06.010 +requisitos eram que precisávamos amostrar aleatoriamente + +0:25:06.010,0:25:10.150 +na verdade, é um pouco mais fraco, você precisa amostrar incoerentemente, mas na prática + +0:25:10.150,0:25:14.710 +todo mundo faz amostras aleatoriamente, então é essencialmente a mesma coisa agora aqui + +0:25:14.710,0:25:18.910 +estamos amostrando colunas aleatoriamente, mas dentro das colunas não + +0:25:18.910,0:25:22.330 +amostra a razão é que não é mais rápido na máquina que a máquina pode + +0:25:22.330,0:25:25.930 +capturar uma coluna tão rapidamente quanto você poderia capturar meia coluna, então nós apenas + +0:25:25.930,0:25:29.350 +tipo de capturar uma coluna inteira para que não seja mais aleatório, então é um + +0:25:29.350,0:25:33.760 +tipo de problema com isso o outro problema é o tipo de suposições + +0:25:33.760,0:25:36.850 +desta teoria do sensoriamento comprimido são violados pelo tipo de imagens que queremos + +0:25:36.850,0:25:41.020 +para reconstruir eu mostro à direita eles são um exemplo de sensoriamento comprimido + +0:25:41.020,0:25:44.560 +Reconstrução da teoria isso foi um grande passo à frente do que eles poderiam fazer + +0:25:44.560,0:25:48.940 +antes de você obterá algo parecido com isso anteriormente, que foi + +0:25:48.940,0:25:53.020 +realmente considerado o melhor que algumas pessoas fariam quando esse resultado saiu + +0:25:53.020,0:25:57.430 +Jurei que isso era impossível, na verdade não é, mas você precisa de um pouco + +0:25:57.430,0:26:00.550 +suposições e essas suposições são bastante críticas e eu as menciono lá + +0:26:00.550,0:26:05.080 +então você precisa de uma imagem esparsa agora que mi a -- majors não esparsos por esparsos + +0:26:05.080,0:26:09.370 +Quero dizer, tem muitos pixels zero ou pretos, claramente não é esparso, mas + +0:26:09.370,0:26:13.660 +podem ser representados esparsamente ou aproximadamente esparsamente se você fizer um + +0:26:13.660,0:26:18.160 +decomposição wavelet agora não vou entrar em detalhes há um pouco de + +0:26:18.160,0:26:20.920 +problema, embora seja apenas aproximadamente esparso e quando você faz essa wavelet + +0:26:20.920,0:26:24.489 +decomposição é por isso que esta não é uma reconstrução perfeita se foi muito + +0:26:24.489,0:26:28.060 +esparso no domínio wavelet e perfeitamente que seria exatamente no + +0:26:28.060,0:26:33.160 +igual à imagem da esquerda e esta detecção compactada é baseada na + +0:26:33.160,0:26:36.220 +campo de otimização meio que revitaliza muitas das técnicas + +0:26:36.220,0:26:39.550 +que as pessoas usam há muito tempo, a maneira como você obtém essa reconstrução é + +0:26:39.550,0:26:45.130 +você resolve um pequeno problema de mini otimização em cada etapa de cada imagem + +0:26:45.130,0:26:47.830 +você deseja reconstruir quantas outras máquinas para que sua máquina tenha que resolver um + +0:26:47.830,0:26:51.030 +problema de otimização para cada imagem toda vez que resolve este pequeno + +0:26:51.030,0:26:57.340 +problema quadrático com esse tipo de termo de regularização complicado, então isso + +0:26:57.340,0:27:00.700 +é ótimo para otimização ou todas essas pessoas que estavam sendo mal pagas + +0:27:00.700,0:27:03.780 +empregos em universidades, de repente, suas pesquisas estavam na moda e + +0:27:03.780,0:27:09.370 +corporações precisavam de sua ajuda, então isso é ótimo, mas podemos fazer melhor para que possamos + +0:27:09.370,0:27:13.120 +em vez de resolver esse problema de minimização a cada passo de tempo, usarei um + +0:27:13.120,0:27:16.960 +rede neural tão obviamente estar aqui arbitrariamente para representar a enorme + +0:27:16.960,0:27:24.190 +sua rede é muito importante, é claro, esperamos que possamos aprender em sua rede + +0:27:24.190,0:27:28.000 +de complexidade suficiente que pode essencialmente resolver a otimização + +0:27:28.000,0:27:31.240 +problema em uma etapa, ele apenas gera uma solução que é tão boa quanto a + +0:27:31.240,0:27:35.200 +solução do problema de otimização agora isso seria considerado impossível 15 + +0:27:35.200,0:27:39.820 +anos atrás, agora sabemos melhor, então não é muito difícil, na verdade, nós + +0:27:39.820,0:27:44.980 +pode apenas dar um exemplo de que podemos resolver alguns desses alguns, quero dizer, como alguns + +0:27:44.980,0:27:48.520 +centenas de milhares desses problemas de otimização levam a solução e a entrada + +0:27:48.520,0:27:53.620 +e vamos forçar uma rede neural para mapear da entrada para a solução que é + +0:27:53.620,0:27:56.830 +na verdade, um pouco abaixo do ideal porque ficamos enfraquecidos em alguns casos, conhecemos um + +0:27:56.830,0:28:00.070 +melhor solução do que a solução para o problema de otimização, podemos reunir que + +0:28:00.070,0:28:04.780 +medindo o paciente e isso é o que realmente fazemos na prática para não + +0:28:04.780,0:28:07.000 +tentar resolver o problema de otimização que tentamos e chegar a um ainda melhor + +0:28:07.000,0:28:11.260 +solução e isso funciona muito bem, então vou lhe dar um exemplo muito simples de + +0:28:11.260,0:28:14.740 +isso então é isso que você pode fazer muito melhor do que o sensorial comprimido + +0:28:14.740,0:28:18.580 +reconstrução usando uma rede neural e esta rede envolve os truques + +0:28:18.580,0:28:23.140 +Eu mencionei, então é treinado usando Adam, ele usa normalização de norma de grupo + +0:28:23.140,0:28:28.690 +camadas e redes neurais convolucionais como você já aprendeu e + +0:28:28.690,0:28:33.970 +usa uma técnica conhecida como u nets que você pode usar mais tarde no curso não + +0:28:33.970,0:28:37.390 +com certeza, mas não é uma modificação muito complicada de apenas um + +0:28:37.390,0:28:40.660 +funciona como sim, este é o tipo de coisa que você pode fazer e isso é muito + +0:28:40.660,0:28:44.880 +perto de aplicações práticas, então você verá essas imagens de ressonância magnética aceleradas + +0:28:44.880,0:28:49.750 +varreduras acontecendo na prática clínica em apenas alguns anos cansados, isso não é + +0:28:49.750,0:28:53.980 +vaporware e sim, isso é tudo que eu queria falar sobre você falar + +0:28:53.980,0:28:58.620 +hoje otimização e a morte da otimização obrigado \ No newline at end of file diff --git a/docs/pt/week05/practicum05.sbv b/docs/pt/week05/practicum05.sbv new file mode 100644 index 000000000..e1143a002 --- /dev/null +++ b/docs/pt/week05/practicum05.sbv @@ -0,0 +1,1241 @@ +0:00:00.000,0:00:05.339 +última vez que vimos que uma matriz pode ser escrita basicamente deixe-me desenhar aqui + +0:00:05.339,0:00:12.719 +a matriz, então tínhamos papéis semelhantes e, em seguida, multiplicamos normalmente design por + +0:00:12.719,0:00:18.210 +uma coluna tudo bem e sempre que multiplicarmos esses caras você pode ver esses + +0:00:18.210,0:00:23.340 +e como dois tipos dois tipos diferentes equivalentes de representação + +0:00:23.340,0:00:28.980 +você pode ver direito você não é legível ok então você pode ver basicamente como + +0:00:28.980,0:00:35.430 +a saída deste produto foi uma sequência de vezes como a primeira linha + +0:00:35.430,0:00:40.469 +este vetor de coluna e, novamente, estou bem encolhendo-os, isso deve ser + +0:00:40.469,0:00:46.170 +o mesmo tamanho certo, porque senão você não pode multiplicá-los, então você + +0:00:46.170,0:00:52.170 +ter este e assim por diante até o último e este vai ser o meu final + +0:00:52.170,0:01:00.960 +vetor e vimos que cada um desses corpos aqui o que são esses que falo + +0:01:00.960,0:01:05.339 +para mim, por favor, há um produto escalar certo, mas o que + +0:01:05.339,0:01:08.820 +eles representam o que é como podemos chamá-lo qual é outro nome para chamar + +0:01:08.820,0:01:13.290 +um produto escalar eu mostro a você da última vez uma demonstração com algum governo Chi + +0:01:13.290,0:01:18.119 +trigonometria certo o que é isso então esta é toda a projeção se você + +0:01:18.119,0:01:22.619 +fale sobre geometria ou você pode pensar nisso como um cosseno normalizado freira + +0:01:22.619,0:01:29.310 +valor certo então este vai ser minha projeção basicamente de um kernel ou + +0:01:29.310,0:01:36.030 +meu sinal de entrada no kernel certo, então essas são projeções de projeção bem + +0:01:36.030,0:01:40.619 +e então houve também uma outra interpretação disso como há + +0:01:40.619,0:01:45.390 +outra maneira de ver isso que era basicamente o que tínhamos na primeira coluna + +0:01:45.390,0:01:53.579 +da matriz a multiplicado pelo primeiro elemento do X destes deste vetor + +0:01:53.579,0:01:58.260 +certo, então de volta ao elemento número um, então você teve uma segunda chamada + +0:01:58.260,0:02:04.020 +tempo é o segundo elemento do vetor X até chegar à última coluna + +0:02:04.020,0:02:11.100 +certo vezes o último um elemento certo suponha que isso é longo N e isso é + +0:02:11.100,0:02:16.110 +M vezes n certo, então a altura novamente será a dimensão em direção a nós + +0:02:16.110,0:02:19.550 +deveria - e a largura de uma matriz é a dimensão de onde estamos vindo + +0:02:19.550,0:02:24.810 +a segunda parte foi a seguinte, então dissemos em vez de usar esta matriz aqui + +0:02:24.810,0:02:29.450 +em vez disso, já que estamos fazendo convoluções porque gostaríamos de explorar a dispersão + +0:02:29.450,0:02:35.400 +estacionaridade e composicionalidade dos dados ainda usamos a mesma matriz aqui + +0:02:35.400,0:02:41.370 +talvez certo nós usamos o mesmo cara aqui, mas então esses kernels nós vamos + +0:02:41.370,0:02:45.510 +estar usando-os repetidamente a mesma corrente em todo o sinal + +0:02:45.510,0:02:51.360 +certo, então, neste caso, a largura desta matriz não é mais n + +0:02:51.360,0:02:56.820 +como estava aqui vai ser K que vai ser o tamanho do kernel certo então aqui + +0:02:56.820,0:03:03.090 +Eu vou desenhar minha matriz mais fina e esta vai ser K minúsculo K + +0:03:03.090,0:03:10.140 +e a altura talvez ainda possamos chamar de n ok tudo bem então vamos dizer aqui eu + +0:03:10.140,0:03:18.230 +tenho vários kernels, por exemplo, deixe-me ter meu tsiyon carnal, então eu posso ter meu + +0:03:18.230,0:03:25.080 +outro não verde deixa eu trocar vamos colocar rosa pra você ter esse e + +0:03:25.080,0:03:33.180 +então você pode ter um verde certo e assim por diante, então como usamos esses kernels certo + +0:03:33.180,0:03:38.280 +agora, basicamente, podemos usar esses kernels empilhando-os e deslocando + +0:03:38.280,0:03:43.650 +um pouco certo, então tiramos o primeiro kernel daqui e então você está + +0:03:43.650,0:03:50.519 +vai pegar basicamente você pega o primeiro cara aqui então você muda + +0:03:50.519,0:03:58.290 +desloque-o e assim por diante até obter toda a matriz e estávamos colocando um 0 + +0:03:58.290,0:04:02.100 +aqui e um 0 aqui certo isso é apenas recapitulação e então você tem este para o + +0:04:02.100,0:04:11.379 +cor azul agora você faz mágica aqui e apenas copia copia e eu cola + +0:04:11.379,0:04:19.370 +e agora você também pode fazer cores ver mágica fantástica e temos um rosa e + +0:04:19.370,0:04:25.360 +então você tem o último certo posso fazer a mesma cópia sim eu posso fazer fantástico + +0:04:25.360,0:04:29.080 +então você não pode copiar e colar no papel + +0:04:29.080,0:04:38.419 +tudo certo cor e o último verde claro tudo bem então nós apenas + +0:04:38.419,0:04:44.479 +duplique quantas matrizes temos agora quantas camadas não conte o + +0:04:44.479,0:04:50.600 +número como se houvesse letras na tela e K ou M o que é o que é + +0:04:50.600,0:05:00.620 +K do lado geralmente você está apenas supondo que não deveria estar supondo que deveria + +0:05:00.620,0:05:07.120 +me diga a resposta correta eu penso nisso como uma entrevista de emprego estou treinando você + +0:05:07.120,0:05:14.990 +então quantos mapas temos e certo então este aqui são tantos quanto o meu M que + +0:05:14.990,0:05:21.470 +é o número de linhas dessa coisa inicial aqui, tudo bem, então o que + +0:05:21.470,0:05:30.289 +é em vez disso a largura deste pequeno kernel aqui ok certo ok qual é o + +0:05:30.289,0:05:41.349 +altura desta matriz qual é a altura da matriz + +0:05:42.340,0:05:45.480 +você com certeza tente novamente + +0:05:49.220,0:06:04.310 +não consigo ouvir e menos k mais um ok e o final qual é a saída disso + +0:06:04.310,0:06:08.660 +coisa certa, então a saída será um vetor que será de altura + +0:06:08.660,0:06:19.430 +a mesma direita e menos k mais 1 e então deve estar correto sim, mas então + +0:06:19.430,0:06:27.890 +quantos qual é a espessura desse vetor final M certo então essas coisas aqui + +0:06:27.890,0:06:35.600 +e vai tão grosso quanto M à direita, então é aqui que saímos da última vez, mas depois + +0:06:35.600,0:06:39.770 +alguém me perguntou agora então percebi que temos aqui tantos quantos os diferentes + +0:06:39.770,0:06:45.170 +cores certas, por exemplo, neste caso, se eu apenas desenhar para ter certeza de que + +0:06:45.170,0:06:49.730 +entenda o que está acontecendo você tem a primeira coisa aqui agora você tem a segunda + +0:06:49.730,0:06:55.600 +um aqui e eu tenho o terceiro certo neste caso tudo bem então da última vez eles + +0:06:59.750,0:07:03.650 +me perguntou se alguém me perguntou no final da aula, então como fazemos convolução + +0:07:03.650,0:07:09.760 +quando acabamos nessa situação aqui porque aqui assumimos que meu + +0:07:09.760,0:07:14.990 +cantos são apenas você sabe o que quer que K longo, digamos três longos, mas então eles + +0:07:14.990,0:07:21.380 +são apenas um pequeno vetor certo e então alguém me disse não, então o que você faz + +0:07:21.380,0:07:24.950 +daqui como vamos continuar porque agora temos uma espessura antes + +0:07:24.950,0:07:32.510 +começamos com algo aqui este vetor que tinha apenas n elementos certo + +0:07:32.510,0:07:35.690 +você está acompanhando até agora estou indo mais rápido porque já vimos esses + +0:07:35.690,0:07:44.030 +coisas que estou apenas revisando mas você está comigo até agora sim não sim ok + +0:07:44.030,0:07:47.720 +fantástico, então vamos ver como realmente continuamos, então a coisa é + +0:07:47.720,0:07:51.680 +mostrar a você agora é assumir que começamos com esse vetor longo + +0:07:51.680,0:08:01.400 +qual era de altura qual era a altura e certo mas neste caso também este + +0:08:01.400,0:08:13.060 +significa que temos algo parecido com isso e você tem basicamente aqui + +0:08:13.060,0:08:20.720 +isso é 1 isso também é 1 então só temos um sinal monofônico por exemplo e isso + +0:08:20.720,0:08:26.300 +estava na altura certo, então vamos supor que agora estamos usando um + +0:08:26.300,0:08:33.950 +sistema estereofônico então qual vai ser o meu domínio aqui para que você saiba que meu X pode ser + +0:08:33.950,0:08:39.740 +pensado como uma função que vai do domínio ao ℝ^{número de canais}, então + +0:08:39.740,0:08:47.840 +o que é esse cara aqui sim x é uma dimensão e em algum lugar então o que é isso + +0:08:47.840,0:08:59.930 +Ω vimos este slide no último slide da lição de terça-feira à direita, segundo Ω é + +0:08:59.930,0:09:11.720 +não é um conjunto de números reais ninguém tenta estamos usando computadores é hora + +0:09:11.720,0:09:16.520 +linha sim e quantas amostras você tem um número de amostra número de amostra dois + +0:09:16.520,0:09:21.710 +ou amostra número três para que você tenha basicamente um subconjunto do espaço natural + +0:09:21.710,0:09:30.860 +certo, então este vai ser algo como 0 1 2, então no set, que é + +0:09:30.860,0:09:36.410 +vai ser subconjunto de ℕ certo, então não é ℝ. ℝ vai ser se você tiver tempo + +0:09:36.410,0:09:45.850 +domínio contínuo o que você vê neste caso no caso que acabei de mostrar + +0:09:45.850,0:09:55.160 +até agora o que é visto neste caso agora número de canais de entrada porque isso é + +0:09:55.160,0:10:00.740 +vai ser meu X certo esta é minha entrada então neste caso nós mostramos até agora neste + +0:10:00.740,0:10:07.220 +caso aqui estávamos usando apenas um, então significa que temos um áudio monofônico, vamos + +0:10:07.220,0:10:10.880 +sete agora a suposição faz a suposição de que esse cara é que é + +0:10:10.880,0:10:22.780 +serão dois de tal forma que você estará falando sobre sinal fonético estéreo certo + +0:10:23.200,0:10:27.380 +ok, então vamos ver como isso muda, então + +0:10:27.380,0:10:38.450 +neste caso, deixe-me pensar sim, então como faço para desenhar, vou desenhar certo + +0:10:38.450,0:10:43.400 +reclame pouco se você não segue você está seguindo até agora sim porque se + +0:10:43.400,0:10:46.550 +eu assisto meu tablet eu não vejo você direito então você deveria estar reclamando se + +0:10:46.550,0:10:50.750 +algo não faz sentido direito senão fica chato de esperar + +0:10:50.750,0:10:56.390 +e assistindo você o tempo todo certo sim não sim ok eu sou chato ok + +0:10:56.390,0:11:00.080 +obrigado tudo bem então temos aqui esse sinal + +0:11:00.080,0:11:07.280 +certo e agora temos alguma espessura, neste caso, qual é o + +0:11:07.280,0:11:14.660 +espessura desse cara veja bem então neste caso este vai ser C e + +0:11:14.660,0:11:18.589 +no caso do sinal estereofônico, você terá apenas dois canais restantes + +0:11:18.589,0:11:30.170 +e certo e este continua indo para baixo tudo bem, então nossos kernels se eu tivesse + +0:11:30.170,0:11:35.030 +gostaria de realizar uma convolução sobre este sinal certo para que você tenha o mesmo + +0:11:35.030,0:11:44.150 +buceta certo e assim por diante direito se eu gostaria de realizar uma convolução um grande + +0:11:44.150,0:11:47.089 +convolução não estou falando de duas deconvoluções né porque são + +0:11:47.089,0:11:52.670 +ainda usando o domínio que é o número um, então isso é realmente importante + +0:11:52.670,0:11:58.510 +então se eu perguntar que tipo de sinal é esse, você vai ser basicamente + +0:11:58.510,0:12:02.890 +você tem que olhar para este número aqui, então estamos falando de um + +0:12:02.890,0:12:12.490 +sinal dimensional que é um domínio dimensional direito 1d domínio ok + +0:12:12.490,0:12:17.710 +então ainda estamos usando um sinal 1d, mas neste caso você sabe que tem dois + +0:12:17.710,0:12:25.750 +valores por ponto, então que tipo de kernels vamos usar, então vou apenas + +0:12:25.750,0:12:31.450 +desenhá-lo neste caso, vamos usar algo parecido com isso, então estou + +0:12:31.450,0:12:37.990 +vai desenhar esse cara vamos dizer que eu tenho K aqui que vai ser a minha largura + +0:12:37.990,0:12:42.700 +do kernel, mas neste caso eu também vou ter alguma espessura neste caso + +0:12:42.700,0:12:56.230 +aqui, então basicamente você aplica essa coisa aqui ok e então você pode ir + +0:12:56.230,0:13:04.060 +segunda linha e terceira linha e assim por diante, então você ainda pode ter como aqui m + +0:13:04.060,0:13:11.590 +grãos, mas neste caso você também tem alguma espessura que deve corresponder ao + +0:13:11.590,0:13:17.680 +outra espessura certa, então essa espessura aqui tem que corresponder à espessura do + +0:13:17.680,0:13:23.980 +tamanho de entrada, então deixe-me mostrar como aplicar a convolução para que você + +0:13:23.980,0:13:37.980 +pegue uma dessas fatias aqui e então você vai aplicar isso aqui + +0:13:39.320,0:13:46.190 +ok e então você simplesmente desce por este caminho + +0:13:46.190,0:13:53.870 +tudo bem, então sempre que você aplica isso, você executa esse cara aqui o produto interno + +0:13:53.870,0:14:04.410 +com estes aqui o que você obtém é na verdade um por um é um escalar, então + +0:14:04.410,0:14:09.540 +sempre que eu uso essa coisa laranja aqui do lado esquerdo e faço um ponto + +0:14:09.540,0:14:14.190 +produto escalar produto com este eu apenas recebo um escalar então este é realmente o meu + +0:14:14.190,0:14:19.620 +convolução em 1d a convolução em 1d significa que desce por aqui e + +0:14:19.620,0:14:27.480 +apenas de uma maneira, é por isso que é chamado de 1d, mas multiplicamos cada elemento disso + +0:14:27.480,0:14:36.290 +mascara vezes esse cara aqui agora uma segunda fila e esse cara aqui ok + +0:14:36.290,0:14:41.090 +você viu você multiplicar todos eles você soma todos eles e então você obtém seu primeiro + +0:14:41.090,0:14:47.250 +saída aqui ok então sempre que eu fizer essa multiplicação eu recebo minha primeira saída + +0:14:47.250,0:14:52.050 +aqui então eu continuo deslizando este kernel para baixo e então você vai obter o + +0:14:52.050,0:14:58.380 +segunda saída, terceira saída, quarta e assim por diante até você descer no final, então o que + +0:14:58.380,0:15:03.780 +acontece então acontece que eu vou pegar um kernel diferente eu vou + +0:15:03.780,0:15:07.950 +de volta vamos dizer que eu pego o terceiro ok vamos pegar o segundo eu pego um + +0:15:07.950,0:15:19.050 +segundo e eu faço a mesma operação você vai chegar aqui + +0:15:19.050,0:15:23.240 +na verdade, vamos torná-lo como uma matriz + +0:15:26.940,0:15:33.790 +você desce bem até ir com o último que vai ser o final certo + +0:15:33.790,0:15:45.450 +o kernel vazio que vai descer desta forma você obtém o último aqui + +0:15:51.680,0:15:58.790 +ok sim não esclarecimento confuso então esta foi a pergunta que recebi no final do + +0:15:58.790,0:16:10.339 +class sim Suzy sim porque é um produto escalar de todos esses valores entre então + +0:16:10.339,0:16:18.259 +basicamente fazer a projeção desta parte do sinal neste kernel para que você + +0:16:18.259,0:16:22.879 +gostaria de ver qual é a contribuição como qual é o alinhamento desta parte + +0:16:22.879,0:16:27.350 +do sinal para este subespaço específico ok é assim que uma convolução + +0:16:27.350,0:16:31.850 +funciona quando você tem vários canais até agora vou mostrar apenas com single + +0:16:31.850,0:16:35.319 +canal agora temos vários canais ok então oh sim sim em um segundo + +0:16:54.259,0:16:59.509 +e um na parte superior e na parte inferior, então você realmente perde a primeira linha aqui + +0:16:59.509,0:17:04.850 +e você perde a última linha aqui, então no final, neste caso, a saída será + +0:17:04.850,0:17:10.490 +seja n menos três mais um então você perde dois um em cima ok neste caso você + +0:17:10.490,0:17:15.140 +perder dois na parte inferior se você realmente fizer um Centro no centro do + +0:17:15.140,0:17:20.390 +convolução geralmente você perde um no início um no final toda vez que você + +0:17:20.390,0:17:24.409 +execute uma convolução você perde o número da dimensão do kernel + +0:17:24.409,0:17:28.789 +menos um você pode tentar se você colocar sua mão assim você tem um kernel de + +0:17:28.789,0:17:34.340 +três você pega o primeiro aqui e está combinando, então você troca um e depois + +0:17:34.340,0:17:39.440 +você muda para a direita, então tudo bem com a luta, vamos dizer a um pai de dois filhos, então você + +0:17:39.440,0:17:44.149 +tem seu sinal de cinco você tem seu kernel com dois você tem um dois três + +0:17:44.149,0:17:49.070 +e quatro, então começamos com cinco e você termina com quatro porque usa um + +0:17:49.070,0:17:54.500 +tamanho do kernel de dois se você usar um tamanho de kernel de três você obtém um dois e três + +0:17:54.500,0:17:57.289 +então você vai se você usar um tamanho de kernel de três ok + +0:17:57.289,0:18:01.010 +então você sempre pode tentar fazer isso bem, então eu vou te mostrar agora o + +0:18:01.010,0:18:07.040 +dimensões desses kernels e as saídas com PyTorch ok Sim Não + +0:18:07.040,0:18:18.500 +tudo bem, tudo bem, senhor, você pode ver alguma coisa + +0:18:18.500,0:18:25.520 +sim certo quero dizer zoom um pouco mais ok então agora podemos ir nós fazemos + +0:18:25.520,0:18:33.770 +conda ativar pDL, pytorch Deep Learning. + +0:18:33.770,0:18:40.520 +Então aqui podemos apenas executar o ipython se eu pressionar ctrl LI limpar a tela e + +0:18:40.520,0:18:49.820 +podemos fazer a importação da tocha, então eu posso fazer a partir da tocha import nn, então agora podemos ver + +0:18:49.820,0:18:54.500 +por exemplo chamado vamos definir minha camada convolucional convolucional é + +0:18:54.500,0:18:59.930 +vai ser igual a NN conf e então eu posso continuar até conseguir + +0:18:59.930,0:19:04.220 +este, digamos sim, digamos que não tenho ideia de como usar essa função, apenas + +0:19:04.220,0:19:08.750 +coloco um ponto de interrogação eu pressiono ENTER e vou ver aqui agora a documentação + +0:19:08.750,0:19:13.460 +ok, então, neste caso, você terá o primeiro item que será a entrada + +0:19:13.460,0:19:19.820 +canal então eu tenho os canais de saída então eu tenho o canto suspira bem então + +0:19:19.820,0:19:24.290 +por exemplo vamos colocar aqui os canais de entrada temos um estéreo + +0:19:24.290,0:19:30.530 +sinal então colocamos dois canais o número de cantos que dissemos que era M e vamos + +0:19:30.530,0:19:36.650 +digamos que temos 16 kernels, então este é o número de kernels que vou usar e + +0:19:36.650,0:19:41.810 +então vamos ter o tamanho do nosso kernel do que eu uso aqui, então vamos ter K ou + +0:19:41.810,0:19:47.570 +o tamanho do kernel é igual a 3 ok então aqui vou definir minha primeira convolução + +0:19:47.570,0:19:52.910 +objeto então se eu imprimir este vem você vai ver que temos uma convolução a + +0:19:52.910,0:19:57.580 +2d combo desculpe 1 deconvolução fez isso bem, então temos uma convolução 1d + +0:20:02.149,0:20:08.869 +que vai de dois canais, de modo estereofônico para dezesseis canais, significa + +0:20:08.869,0:20:16.039 +Eu uso dezesseis kernels o tamanho do skirmish é 3 e então o passo também é 1 ok então + +0:20:16.039,0:20:23.859 +neste caso, vou verificar quais serão meus pesos convolucionais + +0:20:27.429,0:20:33.379 +qual é o tamanho dos pesos quantos pesos temos quantos quantos + +0:20:33.379,0:20:40.069 +quantos aviões temos para os pesos 16 certo então temos 16 pesos o que é + +0:20:40.069,0:20:53.649 +a duração do dia da chave de D do kernel ok Oh o que é isso - + +0:20:54.549,0:21:00.349 +Janis está certo, então eu tenho 16 desses scanners que têm espessura - e então + +0:21:00.349,0:21:05.539 +comprimento de 3 ok faz sentido porque você vai aplicar cada um desses + +0:21:05.539,0:21:11.629 +16 em todo o sinal então vamos ter o meu sinal agora você vai ser vai + +0:21:11.629,0:21:20.599 +ser igual a idade ponto R e e e oh suspiros não sei digamos 64 eu também + +0:21:20.599,0:21:25.129 +tenho que dizer que eu tenho um lote de tamanho 1, então eu tenho um site virtual, então eu só tenho + +0:21:25.129,0:21:31.879 +um sinal e então isso vai ser 64 quantos canais nós dissemos que isso tem dois + +0:21:31.879,0:21:37.819 +certo então eu tenho um sinal um exemplo que tem dois canais e tem 64 + +0:21:37.819,0:21:46.689 +samples então este é o meu X espera qual é o tamanho do viés convolucional + +0:21:48.320,0:21:54.380 +um 16 certo porque você tem um viés / simples / / / muito bem, então o que vai estar em + +0:21:54.380,0:22:07.539 +nossa minha convolução de X a saída olá, então ainda vou ter uma amostra certa + +0:22:07.539,0:22:15.919 +quantos canais 16 qual vai ser a duração do sinal ok isso é + +0:22:15.919,0:22:22.700 +bom 6 conserte ok fantástico tudo bem e daí se eu vou usar + +0:22:22.700,0:22:32.240 +uma convolução com tamanho do kernel 5 o que eu recebo agora ainda para gritar não consigo + +0:22:32.240,0:22:36.320 +ouço você 60 ok você está seguindo fantástico ok + +0:22:36.320,0:22:44.059 +então vamos tentar agora usar uma imagem hiperespectral com uma convolução 2d + +0:22:44.059,0:22:49.100 +ok, então eu vou codificar agora minha convolução aqui vai ser minha entrada + +0:22:49.100,0:22:55.490 +este caso está correto ou vai ser um conf venha para D novamente não sei como + +0:22:55.490,0:22:59.059 +uso então eu coloco um ponto de interrogação e depois tenho aqui canal de entrada canal de saída + +0:22:59.059,0:23:05.450 +critique o preenchimento estridente ok, então vou colocar entradas testadas entrada + +0:23:05.450,0:23:10.429 +canal, então é uma imagem hiperespectral com 20 planos, então qual será o + +0:23:10.429,0:23:16.149 +insira neste caso 20 certo porque você começa a partir de 20 bandas espectrais + +0:23:16.149,0:23:20.419 +então vamos inserir o número de saída de canais, digamos que estamos + +0:23:20.419,0:23:25.330 +vou usar novamente 16, neste caso, vou inserir o tamanho do kernel + +0:23:25.330,0:23:33.440 +já que estou planejando usar ok vamos definir vamos definir meu + +0:23:33.440,0:23:40.120 +sinal primeiro, então meu X será um ponto de tocha R e, digamos, uma amostra com + +0:23:40.120,0:23:52.820 +20 canais de altura por exemplo eu acho que 6128 bem segure em 64 e depois com + +0:23:52.820,0:23:58.820 +128 ok então esta será minha entrada meus dados pessoais ok + +0:23:58.820,0:24:04.370 +então minha convolução agora pode ser algo assim, então eu tenho 20 + +0:24:04.370,0:24:09.110 +canais de entrada 16 nosso Mike Ernest eu vou estar usando então eu vou ser + +0:24:09.110,0:24:15.050 +especificando o tamanho do kernel neste caso vamos usar algo como três + +0:24:15.050,0:24:24.580 +vezes cinco ok então qual vai ser a saída qual é o tamanho do kernel + +0:24:29.170,0:24:47.630 +alguém sim não o que não 20 Janice é os canais de entrada de dados certo então você + +0:24:47.630,0:24:51.680 +tem quantos kernels aqui 16 ai vai + +0:24:51.680,0:24:56.420 +temos 16 kernels que possuem 20 canais de modo que eles podem se sobrepor ao + +0:24:56.420,0:25:03.410 +entrada 3 por 5 direito pequenino como um curto como sim curto, mas grande ok então o que é + +0:25:03.410,0:25:08.140 +vai ser meu conv(x).size ? [1, 16, 62, 124]. Digamos que eu gostaria de + +0:25:16.310,0:25:22.190 +na verdade, adicione de volta o que eu gostaria de liderar a dimensionalidade de canto, posso adicionar alguns + +0:25:22.190,0:25:25.730 +preenchimento certo, então aqui vai ser o passo que eu vou ter um passo de + +0:25:25.730,0:25:29.930 +1 novamente se você não se lembra da sintaxe, basta colocar a pergunta + +0:25:29.930,0:25:35.120 +marca você pode descobrir e, em seguida, quanto esforço devo adicionar agora quanto + +0:25:35.120,0:25:41.870 +passo na direção y desculpe sim quanto preenchimento devo adicionar no + +0:25:41.870,0:25:46.490 +y-direction one porque vai ser um em cima e um embaixo, mas depois + +0:25:46.490,0:25:51.890 +então na direção x ok você sabe que está seguindo fantástico e agora se + +0:25:51.890,0:25:57.320 +Acabei de executar este, você quer obter o tamanho inicial, então agora você tem os dois + +0:25:57.320,0:26:05.500 +1d e 2d o ponto é que qual é a dimensão de um kernel convolucional e + +0:26:05.500,0:26:12.470 +símbolo para o sinal dimensional novamente repito qual é o + +0:26:12.470,0:26:20.049 +dimensionalidade da coleção de uso de cuidados para dados bidimensionais + +0:26:20.860,0:26:27.679 +novamente para a direita, então quatro será o número de dimensões necessárias + +0:26:27.679,0:26:35.659 +para armazenar a coleção de kernels quando você executa convoluções 2d, o que é + +0:26:35.659,0:26:40.370 +vai ser o passo, então se você não sabe como isso funciona, basta colocar um + +0:26:40.370,0:26:44.000 +ponto de interrogação e vou te dizer aqui, então stride vai te dizer que você + +0:26:44.000,0:26:50.929 +afaste-se cada vez que o kernel por um se você for o primeiro + +0:26:50.929,0:26:55.460 +significa que você é apenas o tamanho do lote, então a tocha espera que você sempre use lotes + +0:26:55.460,0:27:00.110 +ou seja, quantos sinais você está usando apenas um certo para que nossa expectativa + +0:27:00.110,0:27:04.549 +se você enviar um vetor de entrada que será o tensor de entrada que tem + +0:27:04.549,0:27:12.289 +dimensão três vai quebrar e reclamar ok então ainda temos algum tempo + +0:27:12.289,0:27:18.049 +para ir na segunda parte, tudo bem, a segunda parte vai ser assim que você + +0:27:18.049,0:27:23.779 +computando algumas derivadas para o primeiro dever de casa, então o + +0:27:23.779,0:27:31.909 +seguindo a lição de casa talvez você tenha que fazer você tem que calcular isso ok você está + +0:27:31.909,0:27:35.510 +deveria estar rindo é uma piada ok lá vai + +0:27:35.510,0:27:43.340 +fantástico, então isso é o que você pode escrever nos anos 90 para o cálculo de + +0:27:43.340,0:27:50.029 +os gradientes do lsdm que serão cobertos, acho que no próximo + +0:27:50.029,0:27:54.950 +próxima lição então como de alguma forma eles ainda tinham que fazer essas coisas direito é gentil + +0:27:54.950,0:28:00.769 +de louco, no entanto, podemos usar o PyTorch para ter computação automática desses + +0:28:00.769,0:28:06.500 +gradientes para que possamos verificar como funciona esse gradiente automático + +0:28:06.500,0:28:12.159 +tudo bem então tudo bem então vamos indo + +0:28:23.090,0:28:28.490 +agora para o notebook número três que é o sim + +0:28:28.490,0:28:33.590 +invisível deixe-me ver se consigo destacar agora é ainda pior ok número três + +0:28:33.590,0:28:41.619 +Gratidão automática Oriole ok, deixe-me ir em tela cheia + +0:28:41.619,0:28:53.029 +ok então fora do nosso tutorial ia estar aqui aqui apenas crie meu tensor que + +0:28:53.029,0:28:57.499 +tem também esses gradientes necessários iguais verdadeiros neste caso, quero dizer perguntando + +0:28:57.499,0:29:02.539 +tocha, por favor, rastreie todos os cálculos de gradiente, ele conseguiu a competição + +0:29:02.539,0:29:07.749 +sobre o tensor de modo que possamos realizar o cálculo de derivadas parciais ok + +0:29:07.749,0:29:13.279 +neste caso eu vou ter meu Y vai ser então X vai ser simplesmente um + +0:29:13.279,0:29:20.419 +dois três quatro o Y vai ser X subtraído o número dois tudo bem então + +0:29:20.419,0:29:26.869 +agora podemos notar que existe essa função grad F n grad f NN FN aqui, então + +0:29:26.869,0:29:32.059 +vamos ver o que é isso vamos sentar lá e ver oh isso é um sub para trás + +0:29:32.059,0:29:37.629 +o que significa que o Y foi gerado por um módulo que realiza o + +0:29:37.629,0:29:43.669 +subtração entre X e e - certo, então você tem X menos 2, portanto, se você + +0:29:43.669,0:29:51.860 +verifique quem gerou Y bem, há um sub um módulo de subtração ok então o que vai + +0:29:51.860,0:30:01.009 +seja agora a função de Deus de X você deveria responder oh ok + +0:30:01.009,0:30:03.580 +por que não há porque eles deveriam ter escrito lá + +0:30:07.580,0:30:12.020 +Alfredo gerou esse certo ok tudo bem nenhum está bem também + +0:30:12.020,0:30:17.000 +ok, então vamos realmente colocar nosso nariz dentro de nós estávamos aqui, podemos realmente + +0:30:17.000,0:30:23.770 +acesse o primeiro elemento você tem o acúmulo porque é o acúmulo eu + +0:30:25.090,0:30:29.830 +não sei, eu esqueci, mas então se você entrar lá você vai ver o + +0:30:29.830,0:30:34.760 +vetor inicial o tensor inicial que estamos usando é o um dois três quatro ok então + +0:30:34.760,0:30:41.390 +dentro deste gráfico computacional você também pode encontrar o tensor original tudo bem + +0:30:41.390,0:30:46.880 +certo, então vamos agora pegar o Z e dentro vai ser meu Y quadrado vezes três e + +0:30:46.880,0:30:51.620 +então eu calculo minha média a vai ser a média de Z certo então se eu calcular + +0:30:51.620,0:30:56.330 +o quadrado dessa coisa aqui e multiplico por três e faço a média + +0:30:56.330,0:31:00.500 +então esta é a parte quadrada vezes 3 e então esta é a média ok então você pode + +0:31:00.500,0:31:06.200 +tente se você não acredita em mim tudo bem então vamos ver como essa coisa se parece + +0:31:06.200,0:31:10.549 +Estarei promovendo aqui todas essas sequências de cálculos, então começamos + +0:31:10.549,0:31:16.669 +por a partir de uma matriz dois a dois o que esse cara estava aqui para comprar - quem é esse X + +0:31:16.669,0:31:22.399 +ok você está seguindo legal, então nós subtraímos - certo e então nós + +0:31:22.399,0:31:27.440 +multiplicado por Y duas vezes certo é por isso que você tem que ro para obter o mesmo + +0:31:27.440,0:31:31.669 +subtração que é o porquê do X menos 2 multiplicado por ele mesmo então + +0:31:31.669,0:31:36.649 +você tem outra multiplicação o que é isso ok multiplique por três e então você + +0:31:36.649,0:31:42.980 +tem o final a média para trás porque este Y é verde porque significa não + +0:31:42.980,0:31:51.140 +ok, sim, obrigado por rir, ok, então eu calculo o suporte de volta certo + +0:31:51.140,0:31:59.409 +o que o pano de fundo faz o que esta linha faz + +0:32:00.360,0:32:08.610 +Eu quero ouvir todos que você conhece já computamos o que radianos certo tão preto + +0:32:08.610,0:32:11.580 +propagação é como você calcula os gradientes como treinamos suas redes + +0:32:11.580,0:32:20.730 +com gradientes não está certo ou o que Aaron disse ontem de volta + +0:32:20.730,0:32:27.000 +propagação é que é usado para calcular o gradiente completamente + +0:32:27.000,0:32:29.970 +coisas diferentes ok por favor mantenha-os separados não mescle + +0:32:29.970,0:32:34.559 +todos eles depois de um tempo que não eles não me veem essas duas coisas continuam + +0:32:34.559,0:32:43.740 +colidindo em um pensamento piegas não é doloroso ok ela vai calcular o + +0:32:43.740,0:32:51.659 +gradientes certo, então adivinhe o que estamos calculando alguns gradientes agora ok, então nós + +0:32:51.659,0:33:02.580 +vá na sua página vai ser o que era uma era a média né então + +0:33:02.580,0:33:10.529 +isso é 1/4 certo a soma de todos aqueles zᵢ + +0:33:10.529,0:33:17.460 +o que então eu vou de 1 a 4 ok então o que é que eu disse que vou + +0:33:17.460,0:33:27.539 +ser igual a 3yᵢ² certo sim sem perguntas não ok tudo bem e então + +0:33:27.539,0:33:36.840 +este é igual a 3(x-2)² certo, então o que ele pertence + +0:33:36.840,0:33:38.899 +para onde pertence a qual é o ℝ + +0:33:44.279,0:33:51.200 +certo então é um scaler tudo bem então agora podemos calcular ∂a/∂x. + +0:33:51.200,0:33:58.110 +Então quanto é esse material que você vai ter 1/4 sai do fórum aqui e + +0:33:58.110,0:34:03.090 +então você sabe, vamos ter este em relação ao elemento xᵢ + +0:34:03.090,0:34:09.179 +ok, então vamos ter este zᵢ dentro é esse, eu tenho o 3yᵢ², + +0:34:09.179,0:34:15.899 +e será 3(xᵢ- 2)². Certo, então esses três vem + +0:34:15.899,0:34:22.080 +aqui os dois também descem e então você multiplica por (xᵢ – 2). + +0:34:22.080,0:34:33.260 +Até agora deve estar correto ok fantástico tudo bem então meu X era esse elemento aqui + +0:34:33.589,0:34:38.190 +na verdade, deixe-me calcular também este, então este vai embora este se torna + +0:34:38.190,0:34:47.690 +verdade isso é 1,5 vezes xᵢ – 3. Certo - 2 - 3 + +0:34:55.159,0:35:06.780 +ok matemática ok ok obrigado tudo bem. Então, o que vai ser ∂a/∂x ? + +0:35:06.780,0:35:11.339 +Na verdade, estou escrevendo a transposição diretamente aqui, então para o primeiro elemento + +0:35:11.339,0:35:18.859 +você tem um você tem um vezes 1,5 então 1,5 menos 3 você obtém 1 menos 1,5 certo + +0:35:18.859,0:35:23.670 +o segundo vai ser 3 menos 3 você tem 0 Ryan isso é 3 menos 3 + +0:35:23.670,0:35:27.420 +talvez eu deva escrever tudo certo para que você esteja realmente seguindo, então você tem + +0:35:27.420,0:35:37.589 +1,5 menos 3 agora você tem 3 menos 3 abaixo você tem 4 ponto 5 menos 3 e então o + +0:35:37.589,0:35:47.160 +o último vai ser 6 menos 3 que vai ser igual a menos 1 ponto 5 + +0:35:47.160,0:35:59.789 +0 1 ponto 5 e depois 3 certo você concorda ok deixa eu escrever isso aqui + +0:35:59.789,0:36:06.149 +ok apenas lembre-se para que você seja computado a retropropagação aqui estou eu + +0:36:06.149,0:36:14.609 +vamos apenas trazê-lo para os gradientes e então a direita é a mesma coisa que nós + +0:36:14.609,0:36:27.630 +chegou aqui certo para não ter que transpor aqui sempre que você tocar + +0:36:27.630,0:36:33.209 +a derivada parcial no PyTorch você obtém a mesma forma é a entrada + +0:36:33.209,0:36:37.469 +dimensão, então, se você tiver um peso em qualquer dimensão, quando você calcular + +0:36:37.469,0:36:41.069 +o parcial você ainda tem a mesma dimensão eles não trocam eles não + +0:36:41.069,0:36:44.789 +vire ok eles só usam isso por praticidade na versão correta eu + +0:36:44.789,0:36:49.919 +significa que o gradiente deve ser a transposição daquela coisa, desculpe fiz + +0:36:49.919,0:36:54.479 +Jacobian que é a transposição do gradiente certo se for um vetor, mas isso + +0:36:54.479,0:37:08.130 +é um tensor, então o que quer que usamos a mesma coisa de forma não, então este + +0:37:08.130,0:37:13.639 +deve ser uma reviravolta acredito que talvez eu esteja errado, mas não acho certo então + +0:37:13.639,0:37:19.919 +isso é como básico esses PyTorch básicos agora você pode fazer coisas malucas porque nós + +0:37:19.919,0:37:23.609 +como um louco certo, quero dizer, eu acho que se você gosta de mim, você + +0:37:23.609,0:37:29.669 +como um louco certo, então aqui eu apenas crio meu + +0:37:29.669,0:37:34.259 +vetor X que vai ser um poço tridimensional um unidimensional + +0:37:34.259,0:37:43.769 +tensor de três itens eu vou multiplicar X por dois então eu chamo isso + +0:37:43.769,0:37:49.859 +um Y então eu começo meu contador a zero e depois até que a norma do Y seja longa + +0:37:49.859,0:37:56.699 +mil abaixo de mil eu continuo dobrando Y ok e assim você pode ficar como um dinâmico + +0:37:56.699,0:38:01.529 +gráfico à direita o gráfico é base é condicional ao aleatório real + +0:38:01.529,0:38:04.979 +inicialização que você nem pode dizer porque eu nem usei uma semente, então + +0:38:04.979,0:38:08.999 +todos que estão executando essas coisas vão obter números diferentes, então estes são + +0:38:08.999,0:38:11.910 +os valores finais do por que você pode me dizer + +0:38:11.910,0:38:23.549 +quantas iterações executamos para que a média dessas coisas seja realmente menor do que um + +0:38:23.549,0:38:27.630 +mil sim, mas então eu estou perguntando se você sabe quantas vezes isso + +0:38:27.630,0:38:41.119 +loop passou por nada bom porque é aleatório aumenta você sabe que é uma pergunta ruim + +0:38:41.119,0:38:45.539 +sobre perguntas ruins da próxima vez que eu tiver algo para você, então eu vou ser + +0:38:45.539,0:38:51.569 +imprimindo este agora estou dizendo que os agarrados são 2048 certo + +0:38:51.569,0:38:55.589 +apenas verifique o central no momento certo este é o gradiente real + +0:38:55.589,0:39:04.739 +então você pode me dizer agora quantas vezes o loop foi para alguém disse 11 como + +0:39:04.739,0:39:14.420 +muitos acabam por 11 ok para as pessoas apenas assar as mãos e os outros + +0:39:14.809,0:39:17.809 +21 ok qualquer outro cara 11 10 + +0:39:25.529,0:39:30.749 +ok, na verdade, temos alguém que tem a solução certa e esse loop continuou + +0:39:30.749,0:39:35.759 +por 10 vezes por que é porque você tem a primeira multiplicação por 2 aqui + +0:39:35.759,0:39:40.589 +e então o loop continua repetidamente e multiplica por 2 certo para que o final + +0:39:40.589,0:39:45.239 +number será o menor número de iterações no loop mais o + +0:39:45.239,0:39:50.779 +adicional como adição e multiplicação fora da direita sim não + +0:39:50.779,0:39:56.670 +você está dormindo talvez tudo bem, eu te disse para não comer antes da aula, caso contrário você + +0:39:56.670,0:40:05.009 +fique grogue bem, então inferência isso é legal, então aqui eu vou estar apenas tendo + +0:40:05.009,0:40:09.420 +tanto no meu X quanto no Y, vamos apenas fazer regressão linear direita linear ou + +0:40:09.420,0:40:17.670 +o que quer que pense que o operador add é apenas o produto escalar, então tanto o X + +0:40:17.670,0:40:21.589 +e W tem o gradiente requerido igual a true + +0:40:21.589,0:40:27.119 +sendo isso significa que vamos acompanhar os gradientes e + +0:40:27.119,0:40:31.290 +o gráfico computacional, então, se eu executar este, você obterá o parcial + +0:40:31.290,0:40:37.710 +derivadas do produto interno em relação ao Z em relação ao + +0:40:37.710,0:40:43.920 +entrada vai ser os pesos certos, então no intervalo está a entrada certa e o + +0:40:43.920,0:40:47.160 +uns são os pesos, então a derivada parcial em relação à entrada é + +0:40:47.160,0:40:50.070 +serão os pesos parciais em relação aos pesos serão os + +0:40:50.070,0:40:56.670 +entrada certo sim não sim ok agora eu só sei que normalmente é este é o + +0:40:56.670,0:41:00.359 +caso eu só precisei de gradientes para meus parâmetros porque vou usar + +0:41:00.359,0:41:06.030 +os gradientes para atualizar mais tarde os parâmetros da mãe são assim + +0:41:06.030,0:41:12.300 +neste caso você não tem nenhum vamos ter neste caso o que eu costumo fazer + +0:41:12.300,0:41:17.250 +quero fazer inferência quando eu faço inferência eu digo tocha uma tocha parar de rastrear qualquer + +0:41:17.250,0:41:22.950 +tipo de operação, então eu digo tocha, não, Deus, por favor, então este, independentemente de + +0:41:22.950,0:41:28.859 +sua entrada sempre tem a grama necessária verdadeira ou falsa, o que quer que eu diga + +0:41:28.859,0:41:35.060 +tocha sem pirralhos você não tem nenhum cálculo um gráfico cuidado certo + +0:41:35.060,0:41:41.130 +portanto, se eu tentar executar a propagação de volta em um tensor que foi + +0:41:41.130,0:41:46.320 +gerado a partir de como não tem realmente você sabe gráfico porque este + +0:41:46.320,0:41:50.940 +não tem um gráfico, você receberá um erro, então, se eu executar este, você receberá + +0:41:50.940,0:41:55.410 +um erro e você tem uma cara muito brava aqui porque é um erro e então + +0:41:55.410,0:42:00.720 +pega seu elemento 0 do tensor não requer grads e não tem um deus + +0:42:00.720,0:42:07.650 +funcionam bem então II que era o sim, o que quer que eles residam aqui, na verdade, então + +0:42:07.650,0:42:11.400 +você não poderia ter problemas que, porque não há gráfico anexado a + +0:42:11.400,0:42:19.710 +que ok perguntas isso é tão poderoso que você não pode fazer isso desta vez com tensor + +0:42:19.710,0:42:26.790 +você está bem, o fluxo do tensor é tipo, sim, mais coisas aqui, na verdade, mais coisas + +0:42:26.790,0:42:30.600 +chegando agora [Aplausos] + +0:42:30.600,0:42:36.340 +então voltamos aqui temos dentro da pasta extra ele tem uns bonitinhos + +0:42:36.340,0:42:40.450 +coisas que eu queria cobrir os dois apenas que vamos apenas para o segundo que eu + +0:42:40.450,0:42:47.290 +acho que desculpe o segundo vai ser o seguinte, então neste caso estamos + +0:42:47.290,0:42:52.750 +vamos gerar nossos próprios módulos específicos, então eu gosto, digamos que eu gostaria de + +0:42:52.750,0:42:58.030 +definir minha própria função, que é uma função incrível super especial, posso decidir se + +0:42:58.030,0:43:02.560 +Eu quero usá-lo para você sabe treinar Nets eu preciso pegar o passe para frente e + +0:43:02.560,0:43:06.220 +também tem que saber qual é a derivada parcial da entrada em relação ao + +0:43:06.220,0:43:10.930 +saída de tal forma que eu possa usar este módulo em qualquer tipo de ponto que você conheça no meu + +0:43:10.930,0:43:15.670 +código interno de tal forma que você saiba que, usando back prop, você conhece a regra da cadeia, você acabou de + +0:43:15.670,0:43:20.320 +ligue a coisa. Yann continuou várias vezes, desde que você saiba parcial + +0:43:20.320,0:43:23.410 +derivada da saída em relação à entrada, você pode conectar essas coisas + +0:43:23.410,0:43:31.690 +em qualquer lugar em sua cadeia de operações, então neste caso definimos minha adição que + +0:43:31.690,0:43:35.620 +está realizando a adição das duas entradas neste caso, mas quando você + +0:43:35.620,0:43:41.130 +execute a retropropagação se tiver uma adição qual é a retropropagação + +0:43:41.130,0:43:47.020 +então, se você tiver uma adição das duas coisas, obterá uma saída quando enviar + +0:43:47.020,0:43:53.320 +abaixo dos gradientes o que acontece com o gradiente que você obtém + +0:43:53.320,0:43:57.160 +sabe copiado em ambos os lados corretos e é por isso que você obtém os dois + +0:43:57.160,0:44:01.390 +cópias ou a mesma coisa e eles são enviados de um lado do outro você + +0:44:01.390,0:44:05.170 +pode executar essas coisas que você verá aqui, você obtém o mesmo gradiente nos dois sentidos + +0:44:05.170,0:44:09.460 +neste caso eu tenho uma divisão então eu venho da mesma coisa e então eu dividi e + +0:44:09.460,0:44:13.180 +Eu tenho essas duas coisas fazendo outra coisa se eu descer com o gradiente o que + +0:44:13.180,0:44:20.080 +eu faço você adicioná-los direito e é por isso que temos aqui o add install você pode + +0:44:20.080,0:44:23.680 +execute este que você verá aqui que tivemos esses dois + +0:44:23.680,0:44:27.910 +gradientes aqui e depois quando você subiu ou desculpe quando você desceu os dois + +0:44:27.910,0:44:30.790 +coisas que os dois gradientes somam e estão aqui ok + +0:44:30.790,0:44:36.190 +então, novamente, se você usar coisas pré-fabricadas no PyTorch. Eles estão corretos este você + +0:44:36.190,0:44:41.080 +pode mexer você pode colocar qualquer tipo de diferente em + +0:44:41.080,0:44:47.950 +para uma função e uma função para trás, acho que ficamos sem tempo outras perguntas + +0:44:47.950,0:44:58.800 +antes de realmente sairmos não, tudo bem, então eu vejo na segunda-feira e fico aquecido \ No newline at end of file diff --git a/docs/pt/week06/06-1.md b/docs/pt/week06/06-1.md new file mode 100644 index 000000000..cb6439af0 --- /dev/null +++ b/docs/pt/week06/06-1.md @@ -0,0 +1,285 @@ +--- +lang: pt +lang-ref: ch.06-1 +lecturer: Yann LeCun +title: Aplicações de Redes Convolucionais +authors: Shiqing Li, Chenqin Yang, Yakun Wang, Jimin Tan +date: 2 Mar 2020 +translator: Bernardo Lago +translation-date: 14 Nov 2021 +--- + + + + +## [Reconhecimento de código postal](https://www.youtube.com/watch?v=ycbMGyCPzvE&t=43s) + + + +Na aula anterior, demonstramos que uma rede convolucional pode reconhecer dígitos, no entanto, a questão permanece, como o modelo escolhe cada dígito e evita perturbação nos dígitos vizinhos. A próxima etapa é detectar objetos não sobrepostos e usar a abordagem geral de Supressão Não Máxima (NMS). Agora, dada a suposição de que a entrada é uma série de dígitos não sobrepostos, a estratégia é treinar várias redes convolucionais e usando o voto da maioria ou escolhendo os dígitos correspondentes à pontuação mais alta gerada pela rede convolucional. + + + +### Reconhecimento com CNN + + + +Aqui apresentamos a tarefa de reconhecer 5 CEPs não sobrepostos. O sistema não recebeu instruções sobre como separar cada dígito, mas sabe que deve prever 5 dígitos. O sistema (Figura 1) consiste em 4 redes convolucionais de tamanhos diferentes, cada uma produzindo um conjunto de saídas. A saída é representada em matrizes. As quatro matrizes de saída são de modelos com largura de kernel diferente na última camada. Em cada saída, há 10 linhas, representando 10 categorias de 0 a 9. O quadrado branco maior representa uma pontuação mais alta nessa categoria. Nestes quatro blocos de saída, os tamanhos horizontais das últimas camadas do kernel são 5, 4, 3 e 2, respectivamente. O tamanho do kernel decide a largura da janela de visualização do modelo na entrada, portanto, cada modelo está prevendo dígitos com base em tamanhos de janela diferentes. O modelo, então, obtém uma votação majoritária e seleciona a categoria que corresponde à pontuação mais alta naquela janela. Para extrair informações úteis, deve-se ter em mente que nem todas as combinações de caracteres são possíveis, portanto, a correção de erros com base nas restrições de entrada é útil para garantir que as saídas sejam códigos postais verdadeiros. + + + +
+
+ Figura 1: Múltiplos classificadores no reconhecimento do CEP +
+ + + +Agora, para impor a ordem dos personagens. O truque é utilizar um algoritmo de caminho mais curto. Uma vez que recebemos faixas de caracteres possíveis e o número total de dígitos a prever, podemos abordar esse problema calculando o custo mínimo de produção de dígitos e transições entre os dígitos. O caminho deve ser contínuo da célula inferior esquerda para a célula superior direita no gráfico, e o caminho é restrito para conter apenas movimentos da esquerda para a direita e de baixo para cima. Observe que se o mesmo número for repetido um ao lado do outro, o algoritmo deve ser capaz de distinguir que há números repetidos em vez de prever um único dígito. + + + +## [Detecção de faces](https://www.youtube.com/watch?v=ycbMGyCPzvE&t=1241s) + + + +As redes neurais convolucionais têm um bom desempenho em tarefas de detecção e a detecção de faces não é exceção. Para realizar a detecção de faces, coletamos um conjunto de dados de imagens com faces e sem faces, no qual treinamos uma rede convolucional com um tamanho de janela de 30 $\times$ 30 pixels e pedimos à rede para dizer se há um rosto ou não. Uma vez treinado, aplicamos o modelo a uma nova imagem e se houver faces dentro de uma janela de 30 $\times$ 30 pixels, a rede convolucional iluminará a saída nos locais correspondentes. No entanto, existem dois problemas. + + + +- **Falsos positivos**: Existem muitas variações diferentes de objetos não-face que podem aparecer em um patch de uma imagem. Durante o estágio de treinamento, o modelo pode não ver todos eles (*ou seja*, um conjunto totalmente representativo de remendos não faciais). Portanto, o modelo pode apresentar muitos falsos positivos no momento do teste. Por exemplo, se a rede não foi treinada em imagens contendo mãos, ela pode detectar rostos com base em tons de pele e classificar incorretamente manchas de imagens contendo mãos como rostos, dando origem a falsos positivos. + + + +- **Tamanho de rosto diferente:** Nem todos os rostos têm 30 $\times$ 30 pixels, portanto, rostos de tamanhos diferentes podem não ser detectados. Uma maneira de lidar com esse problema é gerar versões em várias escalas da mesma imagem. O detector original detectará rostos em torno de 30 $\times$ 30 pixels. Se aplicar uma escala na imagem do fator $\sqrt 2$, o modelo detectará faces que eram menores na imagem original, pois o que era 30 $\times$ 30 agora é 20 $\times$ 20 pixels aproximadamente. Para detectar rostos maiores, podemos reduzir o tamanho da imagem. Esse processo é barato, pois metade das despesas vem do processamento da imagem original sem escala. A soma das despesas de todas as outras redes combinadas é quase a mesma do processamento da imagem original sem escala. O tamanho da rede é o quadrado do tamanho da imagem de um lado, então, se você reduzir a imagem em $\sqrt 2$, a rede que você precisa para executar é menor em um fator de 2. Portanto, o custo geral é $1+1/2+1/4+1/8+1/16…$, que é 2. Executar um modelo em várias escalas apenas duplica o custo computacional. + + + +### Um sistema de detecção de faces em várias escalas + + + +
+
+ Figura 2: Sistema de detecção de faces +
+ + + +Os mapas mostrados na (Figura 3) indicam a pontuação dos detectores de face. Este detector facial reconhece rostos com tamanho de 20 $\times$ 20 pixels. Em escala fina (Escala 3), há muitas pontuações altas, mas não são muito definitivas. Quando o fator de escala aumenta (Escala 6), vemos mais regiões brancas agrupadas. Essas regiões brancas representam rostos detectados. Em seguida, aplicamos a supressão não máxima para obter a localização final do rosto. + + + +
+
+ Figura 3: Pontuações do detector facial para vários fatores de escala +
+ + + +### Supressão não máxima + + + +Para cada região de alta pontuação, provavelmente há um rosto por baixo. Se forem detectados mais rostos muito próximos do primeiro, significa que apenas um deve ser considerado correto e os demais estão errados. Com a supressão não máxima, pegamos a pontuação mais alta das caixas delimitadoras sobrepostas e removemos as outras. O resultado será uma única caixa delimitadora no local ideal. + + + +### Mineração negativa + + + +Na última seção, discutimos como o modelo pode ser executado em um grande número de falsos positivos no momento do teste, pois há muitas maneiras de objetos não-face parecerem semelhantes a um rosto. Nenhum conjunto de treinamento incluirá todos os possíveis objetos não-rostos que se parecem com rostos. Podemos mitigar esse problema por meio da mineração negativa. Na mineração negativa, criamos um conjunto de dados negativos de patches não faciais que o modelo detectou (erroneamente) como faces. Os dados são coletados executando o modelo em entradas que são conhecidas por não conterem faces. Em seguida, treinamos novamente o detector usando o conjunto de dados negativo. Podemos repetir esse processo para aumentar a robustez do nosso modelo contra falsos positivos. + + + +## Segmentação semântica + + + +A segmentação semântica é a tarefa de atribuir uma categoria a cada pixel em uma imagem de entrada. + + + +### [CNN para Visão de Robôs Adaptável de Longo Alcance](https://www.youtube.com/watch?v=ycbMGyCPzvE&t=1669s) + + + +Neste projeto, o objetivo era rotular regiões a partir de imagens de entrada para que um robô pudesse distinguir entre estradas e obstáculos. Na figura, as regiões verdes são áreas nas quais o robô pode dirigir e as regiões vermelhas são obstáculos como grama alta. Para treinar a rede para essa tarefa, pegamos um patch da imagem e rotulamos manualmente como atravessável ou não (verde ou vermelho). Em seguida, treinamos a rede convolucional nos patches, pedindo-lhe para prever a cor do patch. Uma vez que o sistema esteja suficientemente treinado, ele é aplicado em toda a imagem, rotulando todas as regiões da imagem como verdes ou vermelhas. + + + +
+
+ Figura 4: CNN para Visão do Robô Adaptável de Longo Alcance (programa DARPA LAGR 2005-2008) +
+ + + +Havia cinco categorias de previsão: 1) superverde, 2) verde, 3) roxo: linha do pé do obstáculo, 4) obstáculo vermelho 5) super vermelho: definitivamente um obstáculo. + + + +**Rótulos estéreo** (Figura 4, Coluna 2) + As imagens são capturadas pelas 4 câmeras do robô, que são agrupadas em 2 pares de visão estéreo. Usando as distâncias conhecidas entre as câmeras do par estéreo, as posições de cada pixel no espaço 3D são estimadas medindo as distâncias relativas entre os pixels que aparecem em ambas as câmeras em um par estéreo. Este é o mesmo processo que nosso cérebro usa para estimar a distância dos objetos que vemos. Usando as informações de posição estimada, um plano é ajustado ao solo e os pixels são rotulados como verdes se estiverem próximos do solo e vermelhos se estiverem acima dele. + + + +* **Limitações e motivação para ConvNet**: A visão estéreo funciona apenas até 10 metros e dirigir um robô requer visão de longo alcance. Um ConvNet, entretanto, é capaz de detectar objetos em distâncias muito maiores, se treinado corretamente. + + + +
+
+ Figura 5: Pirâmide invariante de escala de imagens normalizadas por distância +
+ + + +* **Servido como entradas do modelo**: o pré-processamento importante inclui a construção de uma pirâmide invariante de escala de imagens normalizadas por distância (Figura 5). É semelhante ao que fizemos anteriormente nesta aula, quando tentamos detectar faces de escalas múltiplas. + + + +**Saídas do modelo** (Figura 4, Coluna 3) + + + +O modelo gera um rótulo para cada pixel na imagem **até o horizonte**. Estas são as saídas do classificador de uma rede convolucional multi-escala. + + + +* **Como o modelo se torna adaptativo**: Os robôs têm acesso contínuo às etiquetas estéreo, permitindo que a rede seja treinada novamente, adaptando-se ao novo ambiente em que se encontra. Observe que apenas a última camada da rede seria refeita -treinado. As camadas anteriores são treinadas em laboratório e fixas. + + + +**Performance do sistema** + + + +Ao tentar chegar a uma coordenada GPS do outro lado de uma barreira, o robô "avistou" a barreira de longe e planejou uma rota para evitá-la. Isso é graças à CNN detectando objetos até 50-100m de distância. + + + +**Limitação** + + + +Na década de 2000, os recursos de computação eram restritos. O robô foi capaz de processar cerca de 1 quadro por segundo, o que significa que ele não seria capaz de detectar uma pessoa que andasse em seu caminho por um segundo inteiro antes de ser capaz de reagir. A solução para essa limitação é um modelo de **Odometria visual de baixo custo**. Não é baseado em redes neurais, tem uma visão de ~2,5m, mas reage rapidamente. + + + +### Análise e rotulagem de cenas + + + +Nesta tarefa, o modelo gera uma categoria de objeto (edifícios, carros, céu, etc.) para cada pixel. A arquitetura também é multi-escala (Figura 6). + + + +
+
+ Figura 6: CNN em várias escalas para análise de cena +
+ + + +Observe que se projetarmos de volta uma saída da CNN na entrada, ela corresponderá a uma janela de entrada de tamanho $46\times46$ na imagem original na parte inferior da Pirâmide Laplaciana. Isso significa que estamos **usando o contexto de $46\times46$ pixels para decidir a categoria do pixel central**. + + + +No entanto, às vezes, esse tamanho de contexto não é suficiente para determinar a categoria de objetos maiores. + + + +**A abordagem multiescala permite uma visão mais ampla, fornecendo imagens extras redimensionadas como entradas.** As etapas são as seguintes: +1. Pegue a mesma imagem, reduza-a pelo fator de 2 e pelo fator de 4, separadamente. +2. Essas duas imagens redimensionadas extras são alimentadas **a mesma ConvNet** (mesmos pesos, mesmos kernels) e obtemos outros dois conjuntos de recursos de nível 2. +3. **Aumente a amostra** desses recursos para que tenham o mesmo tamanho que os Recursos de Nível 2 da imagem original. +4. **Empilhe** os três conjuntos de recursos (amostrados) e os envie a um classificador. + + + +Agora, o maior tamanho efetivo de conteúdo, que é da imagem redimensionada de 1/4, é $184\times 184\, (46\times 4=184)$. + + + +**Desempenho**: sem pós-processamento e execução quadro a quadro, o modelo funciona muito rápido, mesmo em hardware padrão. Tem um tamanho bastante pequeno de dados de treinamento (2k ~ 3k), mas os resultados ainda são recordes. + diff --git a/docs/pt/week06/06-2.md b/docs/pt/week06/06-2.md new file mode 100644 index 000000000..5b4e55ce6 --- /dev/null +++ b/docs/pt/week06/06-2.md @@ -0,0 +1,585 @@ +--- +lang: pt +lang-ref: ch.06-2 +lecturer: Yann LeCun +title: RNNs, GRUs, LSTMs, Modelos de Atenção, Seq2Seq e Redes com Memória +authors: Jiayao Liu, Jialing Xu, Zhengyang Bian, Christina Dominguez +date: 2 March 2020 +translator: Bernardo Lago +translation-date: 14 Nov 2021 +--- + + + +## [Arquitetura de Aprendizagem Profunda](https://www.youtube.com/watch?v=ycbMGyCPzvE&t=2620s) + + + +Na aprendizagem profunda, existem diferentes módulos para realizar diferentes funções. A especialização em aprendizagem profunda envolve o projeto de arquiteturas para concluir tarefas específicas. Semelhante a escrever programas com algoritmos para dar instruções a um computador nos dias anteriores, o aprendizado profundo reduz uma função complexa em um gráfico de módulos funcionais (possivelmente dinâmicos), cujas funções são finalizadas pelo aprendizado. + + + +Como com o que vimos com redes convolucionais, a arquitetura de rede é importante. + + + +## Redes Neurais Recorrentes + + + +Em uma Rede Neural Convolucional, o gráfico ou as interconexões entre os módulos não podem ter laços. Existe pelo menos uma ordem parcial entre os módulos, de modo que as entradas estão disponíveis quando calculamos as saídas. + + + +Conforme mostrado na Figura 1, existem loops nas Redes Neurais Recorrentes. + + + +
+
+Figura 1. Rede Neural Recorrente com loops +
+ + + +- $x(t)$: entrada que varia ao longo do tempo + - $\text{Enc}(x(t))$: codificador que gera uma representação de entrada + - $h(t)$: uma representação da entrada + - $w$: parâmetros treináveis + - $z(t-1)$: estado oculto anterior, que é a saída da etapa de tempo anterior + - $z(t)$: estado oculto atual + - $g$: função que pode ser uma rede neural complicada; uma das entradas é $z(t-1)$ que é a saída da etapa de tempo anterior + - $\text{Dec}(z(t))$: decodificador que gera uma saída + + + + +## Redes Neurais Recorrentes: desenrolando os loops + + + +Desenrole o loop no tempo. A entrada é uma sequência $x_1, x_2, \cdots, x_T$. + + + +
+
+Figura 2. Redes recorrentes com loop desenrolado +
+ + + +Na Figura 2, a entrada é $x_1, x_2, x_3$. + + + +No tempo t = 0, a entrada $x(0)$ é passada para o codificador e ele gera a representação $h(x(0)) = \text{Enc}(x(0))$ e então a passa para G para gerar o estado oculto $z(0) = G(h_0, z', w)$. Em $t = 0$, $z'$ em $G$ pode ser inicializado como $0$ ou inicializado aleatoriamente. $z(0)$ é passado para o decodificador para gerar uma saída e também para a próxima etapa de tempo. + + + +Como não há loops nesta rede, podemos implementar a retropropagação. + + + +A Figura 2 mostra uma rede regular com uma característica particular: cada bloco compartilha os mesmos pesos. Três codificadores, decodificadores e funções G têm os mesmos pesos, respectivamente, em diferentes intervalos de tempo. + + + +BPTT: Retropropagação através do tempo (Backpropagation through time). Infelizmente, o BPTT não funciona tão bem na forma mais simples de RNN. + + + +Problemas com RNNs: + + + +1. Perda da informação do Gradiente (Dissipação do Gradiente) + - Em uma longa sequência, os gradientes são multiplicados pela matriz de peso (transposição) a cada passo de tempo. Se houver valores pequenos na matriz de peso, a norma dos gradientes fica cada vez menor exponencialmente. +2. Explosão de gradientes + - Se tivermos uma matriz de peso grande e a não linearidade na camada recorrente não for saturada, os gradientes explodirão. Os pesos irão divergir na etapa de atualização. Podemos ter que usar uma pequena taxa de aprendizado para que o gradiente descendente funcione. + + + +Uma razão para usar RNNs é a vantagem de lembrar informações do passado. No entanto, ele pode falhar ao memorizar as informações há muito tempo em um RNN simples sem truques. + + + +Um exemplo que tem problema de perda da informação do gradiente: + + + +A entrada são os caracteres de um programa em C. O sistema dirá se é um programa sintaticamente correto. Um programa sintaticamente correto deve ter um número válido de chaves e parênteses. Portanto, a rede deve lembrar quantos parênteses e colchetes devem ser verificados e se todos eles foram fechados. A rede precisa armazenar essas informações em estados ocultos, como um contador. No entanto, devido ao desaparecimento de gradientes, ele deixará de preservar essas informações em um programa longo. + + + +## Truques em RNN + + + +- gradientes de recorte: (evite a explosão de gradientes) + Esmague os gradientes quando eles ficarem muito grandes. +- Inicialização (começar no estádio certo evita explodir / desaparecer) + Inicialize as matrizes de peso para preservar a norma até certo ponto. Por exemplo, a inicialização ortogonal inicializa a matriz de peso como uma matriz ortogonal aleatória. + + + +## Módulos Multiplicativos + + + +Em módulos multiplicativos, ao invés de apenas computar uma soma ponderada de entradas, calculamos produtos de entradas e, em seguida, calculamos a soma ponderada disso. + + + +Suponha que $x \in {R}^{n\times1}$, $W \in {R}^{m \times n}$, $U \in {R}^{m \times n \times d}$ e $z \in {R}^{d\times1}$. Aqui U é um tensor. + + + +$$ +w_{ij} = u_{ij}^\top z = +\begin{pmatrix} +u_{ij1} & u_{ij2} & \cdots &u_{ijd}\\ +\end{pmatrix} +\begin{pmatrix} +z_1\\ +z_2\\ +\vdots\\ +z_d\\ +\end{pmatrix} = \sum_ku_{ijk}z_k +$$ + + + +$$ +s = +\begin{pmatrix} +s_1\\ +s_2\\ +\vdots\\ +s_m\\ +\end{pmatrix} = Wx = \begin{pmatrix} +w_{11} & w_{12} & \cdots &w_{1n}\\ +w_{21} & w_{22} & \cdots &w_{2n}\\ +\vdots\\ +w_{m1} & w_{m2} & \cdots &w_{mn} +\end{pmatrix} +\begin{pmatrix} +x_1\\ +x_2\\ +\vdots\\ +x_n\\ +\end{pmatrix} +$$ + + + +onde $s_i = w_{i}^\top x = \sum_j w_{ij}x_j$. + + + +A saída do sistema é uma soma ponderada clássica de entradas e pesos. Os próprios pesos também são somas ponderadas de pesos e entradas. + + + +Arquitetura de hiper-rede: os pesos são calculados por outra rede. + + + + +## Atenção (Attention) + + + +$x_1$ e $x_2$ são vetores, $w_1$ e $w_2$ são escalares após softmax onde $w_1 + w_2 = 1$, e $w_1$ e $w_2$ estão entre 0 e 1. + + + +$w_1x_1 + w_2x_2$ é uma soma ponderada de $x_1$ e $x_2$ ponderada pelos coeficientes $w_1$ e $w_2$. + + + +Alterando o tamanho relativo de $w_1$ e $w_2$, podemos mudar a saída de $w_1x_1 + w_2x_2$ para $x_1$ ou $x_2$ ou algumas combinações lineares de $x_1$ e $x_2$. + + + +As entradas podem ter vários vetores $x$ (mais de $x_1$ e $x_2$). O sistema escolherá uma combinação apropriada, cuja escolha é determinada por outra variável z. Um mecanismo de atenção permite que a rede neural concentre sua atenção em determinadas entradas e ignore as outras. + + + +A atenção é cada vez mais importante em sistemas de PNL que usam arquiteturas de transformador ou outros tipos de atenção. + + + +Os pesos são independentes dos dados porque z é independente dos dados. + + + + +## [Gated Recurrent Units (GRU)](https://www.youtube.com/watch?v=ycbMGyCPzvE&t=3549s) + + + +Como mencionado acima, RNN sofre de dissipação e explosão de gradientes e não consegue se lembrar dos estados por muito tempo. GRU, [Cho, 2014](https://arxiv.org/abs/1406.1078), é uma aplicação de módulos multiplicativos que tenta resolver esses problemas. É um exemplo de rede recorrente com memória (outra é LSTM). A estrutura de uma unidade GRU é mostrada abaixo: + + + +
+
+Figura 3. Gated Recurrent Unit +
+ + + +$$ +\begin{array}{l} +z_t = \sigma_g(W_zx_t + U_zh_{t-1} + b_z)\\ +r_t = \sigma_g(W_rx_t + U_rh_{t-1} + b_r)\\ +h_t = z_t\odot h_{t-1} + (1- z_t)\odot\phi_h(W_hx_t + U_h(r_t\odot h_{t-1}) + b_h) +\end{array} +$$ + + + +onde $\odot$ denota multiplicação elemento a elemento (produto Hadamard), $ x_t $ é o vetor de entrada, $h_t$é o vetor de saída, $z_t$ é o vetor de porta de atualização, $r_t$ é o vetor de porta de reset, $\phi_h$ é um tanh hiperbólico e $W$, $U$, $b$ são parâmetros que podem ser aprendidos. + + + +Para ser específico, $z_t$ é um vetor de passagem que determina quanto das informações do passado deve ser repassado para o futuro. Ele aplica uma função sigmóide à soma de duas camadas lineares e um viés sobre a entrada $x_t$ e o estado anterior $h_{t-1}$. $z_t$ contém coeficientes entre 0 e 1 como resultado da aplicação de sigmóide. O estado de saída final $ h_t $ é uma combinação convexa de $h_{t-1}$ e $\phi_h(W_hx_t + U_h(r_t\odot h_{t-1}) + b_h)$ via $z_t$. Se o coeficiente for 1, a saída da unidade atual é apenas uma cópia do estado anterior e ignora a entrada (que é o comportamento padrão). Se for menor que um, leva em consideração algumas novas informações da entrada. + + + +A porta de reinicialização $r_t$ é usada para decidir quanto das informações anteriores deve ser esquecido. No novo conteúdo de memória $\phi_h(W_hx_t + U_h(r_t\odot h_{t-1}) + b_h)$, se o coeficiente em $r_t$ for 0, então ele não armazena nenhuma das informações do passado. Se ao mesmo tempo $z_t$ for 0, então o sistema será completamente reiniciado, já que $h_t$ só olharia para a entrada. + + + + +## LSTM (Long Short-Term Memory) + + + +GRU é na verdade uma versão simplificada do LSTM que saiu muito antes, [Hochreiter, Schmidhuber, 1997](https://www.bioinf.jku.at/publications/older/2604.pdf). Ao construir células de memória para preservar informações anteriores, os LSTMs também visam resolver problemas de perda de memória de longo prazo em RNNs. A estrutura dos LSTMs é mostrada abaixo: + + + +
+
+Figura 4. LSTM +
+ + + +$$ +\begin{array}{l} +f_t = \sigma_g(W_fx_t + U_fh_{t-1} + b_f)\\ +i_t = \sigma_g(W_ix_t + U_ih_{t-1} + b_i)\\ +o_t = \sigma_o(W_ox_t + U_oh_{t-1} + b_o)\\ +c_t = f_t\odot c_{t-1} + i_t\odot \tanh(W_cx_t + U_ch_{t-1} + b_c)\\ +h_t = o_t \odot\tanh(c_t) +\end{array} +$$ + + + +onde $\odot$ denota multiplicação elemento a elemento, $x_t\in\mathbb{R}^a$ é um vetor de entrada para a unidade LSTM, $f_t\in\mathbb{R}^h$ é o vetor de ativação do portal de esquecimento , $i_t\in\mathbb{R}^h$ é o vetor de ativação da porta de entrada / atualização, $o_t\in\mathbb{R}^h$ é o vetor de ativação da porta de saída, $h_t\in\mathbb{R}^h$ é o vetor de estado oculto (também conhecido como saída), $c_t\in\mathbb{R}^h$ é o vetor de estado da célula. + + + +Uma unidade LSTM usa um estado de célula $c_t$ para transmitir as informações através da unidade. Ele regula como as informações são preservadas ou removidas do estado da célula por meio de estruturas chamadas de portas. A porta de esquecimento $f_t$ decide quanta informação queremos manter do estado da célula anterior $c_{t-1}$ olhando para a entrada atual e o estado anterior oculto, e produz um número entre 0 e 1 como o coeficiente de $ c_ {t-1} $. $ \ tanh (W_cx_t + U_ch_ {t-1} + b_c) $ calcula um novo candidato para atualizar o estado da célula e, como a porta de esquecimento, a porta de entrada $ i_t $ decide quanto da atualização a ser aplicada. Finalmente, a saída $ h_t $ será baseada no estado da célula $ c_t $, mas será colocada em um $ \ tanh $ e então filtrada pela porta de saída $ o_t $. + + + +Embora os LSTMs sejam amplamente usados na PNL, sua popularidade está diminuindo. Por exemplo, o reconhecimento de voz está se movendo em direção ao uso de CNN temporal, e a PNL está se movendo em direção ao uso de transformadores. + + + + +## Modelo Sequência para Sequência (Seq2Seq) + + + +A abordagem proposta por [Sutskever NIPS 2014](https://papers.nips.cc/paper/5346-sequence-to-sequence-learning-with-neural-networks.pdf) é o primeiro sistema de tradução automática neural a ter comparação desempenho às abordagens clássicas. Ele usa uma arquitetura do tipo codificador-decodificador em que o codificador e o decodificador são LSTMs de várias camadas. + + + +
+
+Figura 5. Seq2Seq +
+ + + +Cada célula na figura é um LSTM. Para o codificador (a parte à esquerda), o número de intervalos de tempo é igual ao comprimento da frase a ser traduzida. Em cada etapa, há uma pilha de LSTMs (quatro camadas no papel) onde o estado oculto do LSTM anterior é alimentado para o próximo. A última camada da última etapa de tempo produz um vetor que representa o significado de toda a frase, que é então alimentado em outro LSTM de várias camadas (o decodificador), que produz palavras no idioma de destino. No decodificador, o texto é gerado de forma sequencial. Cada etapa produz uma palavra, que é alimentada como uma entrada para a próxima etapa de tempo. + + + +Essa arquitetura não é satisfatória de duas maneiras: primeiro, todo o significado da frase deve ser comprimido no estado oculto entre o codificador e o decodificador. Em segundo lugar, os LSTMs na verdade não preservam informações por mais de cerca de 20 palavras. A correção para esses problemas é chamada de Bi-LSTM, que executa dois LSTMs em direções opostas. Em um Bi-LSTM, o significado é codificado em dois vetores, um gerado pela execução do LSTM da esquerda para a direita e outro da direita para a esquerda. Isso permite dobrar o comprimento da frase sem perder muitas informações. + + + + +## Seq2seq com Atenção (Attention) + + + +O sucesso da abordagem acima teve vida curta. Outro artigo de [Bahdanau, Cho, Bengio](https://arxiv.org/abs/1409.0473) sugeriu que, em vez de ter uma rede gigantesca que comprime o significado de toda a frase em um vetor, faria mais sentido se em a cada passo, nós apenas focamos a atenção nos locais relevantes no idioma original com significado equivalente, ou seja, o mecanismo de atenção. + + + +
+
+Figura 6. Seq2seq com Atenção +
+ + + +Em Atenção, para produzir a palavra atual em cada etapa de tempo, primeiro precisamos decidir em quais representações ocultas de palavras na frase de entrada nos concentrar. Essencialmente, uma rede aprenderá a pontuar quão bem cada entrada codificada corresponde à saída atual do decodificador. Essas pontuações são normalizadas por um softmax, então os coeficientes são usados para calcular uma soma ponderada dos estados ocultos no codificador em diferentes etapas de tempo. Ao ajustar os pesos, o sistema pode ajustar a área de entradas para focar. A mágica desse mecanismo é que a rede usada para calcular os coeficientes pode ser treinada por meio de retropropagação. Não há necessidade de construí-los manualmente! + + + +Os mecanismos de atenção transformaram completamente a tradução automática feita por redes neurais. Posteriormente, o Google publicou um artigo [*Attention Is All You Need*](https://arxiv.org/abs/1706.03762) e apresentou o transformer, em que cada camada e grupo de neurônios está implementando a atenção. + + + + +## [Redes com Memória](https://www.youtube.com/watch?v=ycbMGyCPzvE&t=4575s) + + + +Redes de memória derivam do trabalho no Facebook iniciado por [Antoine Bordes](https://arxiv.org/abs/1410.3916) em 2014 e [Sainbayar Sukhbaatar](https://arxiv.org/abs/1503.08895) em 2015. + + + +A ideia de uma rede com memória é que existem duas partes importantes em seu cérebro: uma é o **córtex**, que é onde você tem memória de longo prazo. Há um grupo separado de neurônios chamado **hipocampo**, que envia fios para quase todos os cantos do córtex. Acredita-se que o hipocampo seja usado para memória de curto prazo, lembrando coisas por um período de tempo relativamente curto. A teoria prevalente é que, quando você dorme, muitas informações são transferidas do hipocampo para o córtex para serem solidificadas na memória de longo prazo, já que o hipocampo tem capacidade limitada. + + + +Para uma rede com memória, há uma entrada para a rede, $ x $ (pense nisso como um endereço da memória), e compare este $ x $ com os vetores $k_1, k_2, k_3, \cdots$ ("chaves") por meio de um produto escalar. Coloque-os em um softmax, o que você obtém é uma matriz de números que somam um. E há um conjunto de outros vetores $v_1, v_2, v_3, \cdots$ ("valores"). Multiplique esses vetores pelos escalonadores de softmax e some esses vetores (observe a semelhança com o mecanismo de atenção) para obter o resultado. + + + +
+
+Figura 7. Redes com Memória +
+ + + +Se uma das chaves (*por exemplo* $ k_i $) corresponder exatamente a $ x $, então o coeficiente associado a esta chave será muito próximo de um. Portanto, a saída do sistema será essencialmente $ v_i $. + + + +Esta é a **memória associativa endereçável**. A memória associativa é que, se sua entrada corresponder a uma chave, você obtém *aquele* valor. E esta é apenas uma versão soft diferenciável dele, que permite retropropagar e alterar os vetores por meio de gradiente descendente. + + + +O que os autores fizeram foi contar uma história a um sistema, dando-lhe uma sequência de frases. As sentenças são codificadas em vetores, passando-as por uma rede neural que não foi pré-treinada. As frases são devolvidas à memória deste tipo. Quando você faz uma pergunta ao sistema, você codifica a pergunta e a coloca como a entrada de uma rede neural, a rede neural produz um $ x $ para a memória, e a memória retorna um valor. + + + +Este valor, junto com o estado anterior da rede, é usado para acessar novamente a memória. E você treina toda essa rede para produzir uma resposta à sua pergunta. Após um treinamento extensivo, esse modelo realmente aprende a armazenar histórias e responder a perguntas. + + + +$$ +\alpha_i = k_i^\top x \\ +c = \text{softmax}(\alpha) \\ +s = \sum_i c_i v_i +$$ + + + +Na rede de memória, há uma rede neural que recebe uma entrada e, em seguida, produz um endereço para a memória, retorna o valor para a rede, continua e, por fim, produz uma saída. É muito parecido com um computador, pois há uma CPU e uma memória externa para ler e escrever. + + + +
+ +
+ + + +Figura 8. Comparação entre a rede com memória e um computador (Foto Khan Acadamy) +
+ + + +Existem pessoas que imaginam que você pode realmente construir **computadores diferenciáveis** a partir disso. Um exemplo é a [Máquina de Turing Neural](https://arxiv.org/abs/1410.5401) da DeepMind, que se tornou pública três dias depois que o artigo do Facebook foi publicado no arXiv. + + + +A ideia é comparar entradas para chaves, gerar coeficientes e produzir valores - que é basicamente o que é um transformador. Um transformador é basicamente uma rede neural em que cada grupo de neurônios é uma dessas redes. + diff --git a/docs/pt/week06/06-3.md b/docs/pt/week06/06-3.md new file mode 100644 index 000000000..51e22e580 --- /dev/null +++ b/docs/pt/week06/06-3.md @@ -0,0 +1,734 @@ +--- +lang: pt +lang-ref: ch.06-3 +title: Propriedades dos Sinais Naturais +lecturer: Alfredo Canziani +authors: Zhengyuan Ding, Biao Huang, Lin Jiang, Nhung Le +date: 3 Mar 2020 +translator: Bernardo Lago +translation-date: 14 Nov 2021 +--- + + + + +## [Visão geral](https://www.youtube.com/watch?v=8cAffg2jaT0&t=21s) + + + +RNN é um tipo de arquitetura que podemos usar para lidar com sequências de dados. O que é uma sequência? Com a lição da CNN, aprendemos que um sinal pode ser 1D, 2D ou 3D, dependendo do domínio. O domínio é definido pelo que você está mapeando e para o que está mapeando. Manipular dados sequenciais é basicamente lidar com dados 1D, uma vez que o domínio é o eixo temporal. No entanto, você também pode usar RNN para lidar com dados 2D, onde você tem duas direções. + + + +### Rede Neural "Comum" *vs.* Redes Neurais Recorrentes + + + +A Figura 1 é um diagrama de rede neural comum (vanilla) com três camadas. "Vanilla" é um termo americano que significa simples, comum. O círculo cor-de-rosa é o vetor de entrada x, no centro está a camada oculta em verde e a camada azul final é a saída. Usando um exemplo da eletrônica digital à direita, isso é como uma lógica combinatória, onde a saída de corrente depende apenas da entrada de corrente. + + + +
+
+ Figura 1: Arquitetura "Vanilla" +
+ + + +Em contraste com uma rede neural comum, em redes neurais recorrentes (RNN) a saída atual depende não apenas da entrada atual, mas também do estado do sistema, mostrado na Figura 2. Isso é como uma lógica sequencial na eletrônica digital, onde a saída também depende de um "flip-flop" (uma unidade de memória básica em eletrônica digital). Portanto, a principal diferença aqui é que a saída de uma rede neural comum depende apenas da entrada atual, enquanto a de RNN depende também do estado do sistema. + + + +
+
+ Figura 2: Arquitetura RNN +
+ + + +
+
+ Figura 3: Arquitetura de uma Rede Neural básica +
+ + + +O diagrama de Yann adiciona essas formas entre os neurônios para representar o mapeamento entre um tensor e outro (um vetor para outro). Por exemplo, na Figura 3, o vetor de entrada x será mapeado por meio desse item adicional para as representações ocultas h. Este item é na verdade uma transformação afim, ou seja, rotação mais distorção. Em seguida, por meio de outra transformação, passamos da camada oculta para a saída final. Da mesma forma, no diagrama RNN, você pode ter os mesmos itens adicionais entre os neurônios. + + + +
+
+ Figura 4: Arquitetura RNN de Yann +
+ + + +### Quatro tipos de arquiteturas RNN e exemplos + + + +O primeiro caso é vetor para sequência. A entrada é uma bolha e então haverá evoluções do estado interno do sistema anotadas como essas bolhas verdes. Conforme o estado do sistema evolui, em cada etapa de tempo haverá uma saída específica. + + + +
+
+ Figura 5: Vec para Seq +
+ + + +Um exemplo desse tipo de arquitetura é ter a entrada como uma imagem, enquanto a saída será uma sequência de palavras representando as descrições em inglês da imagem de entrada. Para explicar usando a Figura 6, cada bolha azul aqui pode ser um índice em um dicionário de palavras em inglês. Por exemplo, se o resultado for a frase "Este é um ônibus escolar amarelo". Primeiro, você obtém o índice da palavra "Isto" e, em seguida, obtém o índice da palavra "é" e assim por diante. Alguns dos resultados desta rede são mostrados a seguir. Por exemplo, na primeira coluna a descrição da última imagem é "Uma manada de elefantes caminhando por um campo de grama seca.", Que é muito bem refinada. Então, na segunda coluna, a primeira imagem mostra "Dois cachorros brincando na grama.", Enquanto na verdade são três cachorros. Na última coluna estão os exemplos mais errados, como "Um ônibus escolar amarelo estacionado em um estacionamento". Em geral, esses resultados mostram que essa rede pode falhar drasticamente e funcionar bem às vezes. É o caso de um vetor de entrada, que é a representação de uma imagem, para uma sequência de símbolos, que são, por exemplo, caracteres ou palavras que constituem as frases em inglês. Este tipo de arquitetura é denominado rede autoregressiva. Uma rede autoregressiva é uma rede que fornece uma saída, dado que você alimenta como entrada a saída anterior. + + + +
+
+ Figura 6: vec2seq Exemplo: Imagem para Texto +
+ + + +O segundo tipo é a sequência para um vetor final. Essa rede continua alimentando uma sequência de símbolos e somente no final dá uma saída final. Uma aplicação disso pode ser usar a rede para interpretar Python. Por exemplo, a entrada são essas linhas do programa Python. + + + +
+
+ Figura 7: Seq para Vec +
+ + + +
+
+ Figura 8: Linhas de entrada de códigos Python +
+ + + +Então, a rede será capaz de produzir a solução correta deste programa. Outro programa mais complicado como este: +
+
+ Figura 9: Linhas de entrada de códigos Python em um caso mais completo +
+ + + +Então, a saída deve ser 12184. Esses dois exemplos mostram que você pode treinar uma rede neural para fazer esse tipo de operação. Precisamos apenas alimentar uma sequência de símbolos e fazer com que a saída final seja um valor específico. + + + +O terceiro é seqüência para vetor para seqüência, mostrado na Figura 10. Essa arquitetura costumava ser a forma padrão de realizar a tradução de idiomas. Você começa com uma sequência de símbolos mostrados aqui em rosa. Então, tudo se condensa neste h final, que representa um conceito. Por exemplo, podemos ter uma frase como entrada e comprimi-la temporariamente em um vetor, que representa o significado e a mensagem a ser enviada. Então, depois de obter esse significado em qualquer representação, a rede o desenrola de volta para uma linguagem diferente. Por exemplo, "Hoje estou muito feliz" em uma sequência de palavras em inglês pode ser traduzido para o italiano ou chinês. Em geral, a rede obtém algum tipo de codificação como entradas e as transforma em uma representação compactada. Finalmente, ele realiza a decodificação dada a mesma versão compactada. Recentemente, vimos redes como Transformers, que abordaremos na próxima lição, superar esse método em tarefas de tradução de idiomas. Este tipo de arquitetura era o estado da arte há cerca de dois anos (2018). + + + +
+
+ Figura 10: Seq para Vec para Seq +
+ + + +Se você fizer um PCA sobre o espaço latente, terá as palavras agrupadas por semântica como mostrado neste gráfico. + + + +
+
+ Figura 11: Palavras agrupadas por semântica após PCA +
+ + + +Se aumentarmos o zoom, veremos que no mesmo local estão todos os meses, como janeiro e novembro. +
+
+ Figura 12: Ampliação de grupos de palavras +
+ + + +Se você focar em uma região diferente, obterá frases como "alguns dias atrás" "nos próximos meses" etc. +
+
+ Figura 13: Grupos de palavras em outra região +
+ + + +A partir desses exemplos, vemos que diferentes locais terão alguns significados comuns específicos. + + + +A Figura 14 mostra como, com o treinamento, esse tipo de rede irá captar alguns recursos semânticos. Por exemplo, neste caso, você pode ver que há um vetor conectando homem a mulher e outro entre rei e rainha, o que significa que mulher menos homem será igual a rainha menos rei. Você obterá a mesma distância neste espaço de embeddings aplicado a casos como masculino-feminino. Outro exemplo será caminhar para caminhar e nadar para nadar. Você sempre pode aplicar esse tipo de transformação linear específica, indo de uma palavra para outra ou de um país para a capital. + + + +
+
+ Figura 14: recursos semânticos escolhidos durante o treinamento +
+ + + +O quarto e último caso é seqüência a seqüência. Nessa rede, conforme você começa a alimentar a entrada, a rede começa a gerar saídas. Um exemplo desse tipo de arquitetura é o T9. Se você se lembra de usar um telefone Nokia, receberá sugestões de texto enquanto digita. Outro exemplo é a fala com legendas. Um exemplo legal é este escritor RNN. Quando você começa a digitar "os anéis de Saturno brilharam enquanto", isso sugere o seguinte "dois homens se entreolharam". Esta rede foi treinada em alguns romances de ficção científica para que você simplesmente digite algo e deixe que ela faça sugestões para ajudá-lo a escrever um livro. Mais um exemplo é mostrado na Figura 16. Você insere o prompt superior e, em seguida, esta rede tentará completar o resto. + + + +
+
+ Figura 15: Seq a Seq +
+ + + +
+
+ Figura 16: Modelo de preenchimento automático de texto do modelo Seq para Seq +
+ + + +## [Retropropagação no tempo](https://www.youtube.com/watch?v=8cAffg2jaT0&t=855s) + + + +### Arquitetura do modelo + + + +Para treinar um RNN, a retropropagação através do tempo (BPTT) deve ser usada. A arquitetura do modelo do RNN é fornecida na figura abaixo. O design da esquerda usa a representação do loop, enquanto a figura da direita desdobra o loop em uma linha ao longo do tempo. + + + +
+
+ Figura 17: Retropropagação ao longo do tempo +
+ + + +As representações ocultas são indicadas como + + + +$$ +\begin{aligned} +\begin{cases} +h[t]&= g(W_{h}\begin{bmatrix} +x[t] \\ +h[t-1] +\end{bmatrix} ++b_h) \\ +h[0]&\dot=\ \boldsymbol{0},\ W_h\dot=\left[ W_{hx} W_{hh}\right] \\ +\hat{y}[t]&= g(W_yh[t]+b_y) +\end{cases} +\end{aligned} +$$ + + + +A primeira equação indica uma função não linear aplicada em uma rotação de uma versão da pilha de entrada onde a configuração anterior da camada oculta é anexada. No início, $ h [0] $ é definido como 0. Para simplificar a equação, $ W_h $ pode ser escrito como duas matrizes separadas, $ \ left [W_ {hx} \ W_ {hh} \ right] $, portanto, às vezes a transformação pode ser declarada como + + + +$$ +W_ {hx} \ cdot x [t] + W_ {hh} \ cdot h [t-1] +$$ + + + +que corresponde à representação da pilha da entrada. + + + +$ y [t] $ é calculado na rotação final e então podemos usar a regra da cadeia para retropropagar o erro para a etapa de tempo anterior. + + + +### "Loteamento" na Modelagem de Linguagem + + + +Ao lidar com uma sequência de símbolos, podemos agrupar o texto em diferentes tamanhos. Por exemplo, ao lidar com as sequências mostradas na figura a seguir, a ificação em lote pode ser aplicada primeiro, onde o domínio do tempo é preservado verticalmente. Nesse caso, o tamanho do lote é definido como 4. + + + +
+
+ Figura 18: "Loteamento" (Batch-Ification) +
+ + + +Se o período $T$ da retropropagação baseada no tempo (BPTT) for definido como 3, a primeira entrada $x[1:T]$ e a saída $y[1:T]$ para RNN é determinada como + + + +$$ +\begin{aligned} +x[1:T] &= \begin{bmatrix} +a & g & m & s \\ +b & h & n & t \\ +c & i & o & u \\ +\end{bmatrix} \\ +y[1:T] &= \begin{bmatrix} +b & h & n & t \\ +c & i & o & u \\ +d & j & p & v +\end{bmatrix} +\end{aligned} +$$ + + + +Ao realizar RNN no primeiro lote, em primeiro lugar, alimentamos $x[1] = [a\ g\ m\ s]$ em RNN e forçamos a saída a ser $y[1] = [b\ h\ n\ t]$. A representação oculta $h[1]$ será enviada para a próxima etapa de tempo para ajudar o RNN a prever $y[2]$ a partir de $x[2]$. Depois de enviar $h[T-1]$ para o conjunto final de $x[T]$ e $y[T]$, cortamos o processo de propagação de gradiente para $h[T]$ e $h[0]$ então que os gradientes não se propagam infinitamente (.detach () no Pytorch). Todo o processo é mostrado na figura abaixo. + + + +
+
+ Figura 19: "Loteamento" (Batch-Ification) +
+ + + +## Dissipação e Explosão de Gradiente + + + +### Problema + + + +
+
+ Figura 20: Problema de dissipação +
+ + + +A figura acima é uma arquitetura RNN típica. Para realizar a rotação pelas etapas anteriores no RNN, usamos matrizes, que podem ser consideradas como setas horizontais no modelo acima. Uma vez que as matrizes podem alterar o tamanho das saídas, se o determinante que selecionamos for maior que 1, o gradiente se inflará com o tempo e causará a explosão do gradiente. Relativamente falando, se o autovalor que selecionamos for pequeno em 0, o processo de propagação reduzirá os gradientes e levará ao desaparecimento do gradiente (problema da dissipação de gradiente). + + + +Em RNNs típicos, os gradientes serão propagados por todas as setas possíveis, o que fornece aos gradientes uma grande chance de desaparecer ou explodir. Por exemplo, o gradiente no tempo 1 é grande, o que é indicado pela cor brilhante. Quando ele passa por uma rotação, o gradiente encolhe muito e no tempo 3, ele morre. + + + +### Solução + + + +Um ideal para evitar que gradientes explodam ou desapareçam é pular conexões. Para cumprir isso, multiplique as redes podem ser usadas. + + + +
+
+ Figura 21: Pular conexão +
+ + + +No caso acima, dividimos a rede original em 4 redes. Pegue a primeira rede, por exemplo. Ele obtém um valor da entrada no tempo 1 e envia a saída para o primeiro estado intermediário na camada oculta. O estado tem 3 outras redes onde $ \ circ $ s permite que os gradientes passem enquanto $ - $ s bloqueia a propagação. Essa técnica é chamada de rede recorrente com portas. + + + +O LSTM é um RNN fechado predominante e é apresentado em detalhes nas seções a seguir. + + + +## [Long Short-Term Memory](https://www.youtube.com/watch?v=8cAffg2jaT0&t=1838s) + + + +### Arquitetura do Modelo + + + +Abaixo estão as equações que expressam um LSTM. A porta de entrada é destacada por caixas amarelas, que será uma transformação afim. Essa transformação de entrada multiplicará $ c [t] $, que é nossa porta candidata. + + + +
+
+ Figura 22: Arquitetura LSTM +
+ + + +Não se esqueça de que o gate está multiplicando o valor anterior da memória da célula $ c [t-1] $. O valor total da célula $ c [t] $ é não se esqueça da porta mais a porta de entrada. A representação oculta final é a multiplicação elemento a elemento entre a porta de saída $ o [t] $ e a versão tangente hiperbólica da célula $ c [t] $, de forma que as coisas sejam limitadas. Finalmente, a porta candidata $ \ tilde {c} [t] $ é simplesmente uma rede recorrente. Portanto, temos $ o [t] $ para modular a saída, $ f [t] $ para modular a porta não se esqueça e $ i [t] $ para modular a porta de entrada. Todas essas interações entre memória e portas são interações multiplicativas. $ i [t] $, $ f [t] $ e $ o [t] $ são todos sigmóides, indo de zero a um. Portanto, ao multiplicar por zero, você tem uma porta fechada. Ao multiplicar por um, você tem um portão aberto. + + + +Como desligamos a saída? Digamos que temos uma representação interna roxa $ th $ e colocamos um zero na porta de saída. Então, a saída será zero multiplicado por alguma coisa, e obteremos um zero. Se colocarmos um na porta de saída, obteremos o mesmo valor da representação roxa. +
+
+ Figura 23: Arquitetura LSTM - Saída Ligada +
+ + + +
+
+ Figura 24: Arquitetura LSTM - Saída Desligada +
+ + + +Da mesma forma, podemos controlar a memória. Por exemplo, podemos redefini-lo fazendo com que $ f [t] $ e $ i [t] $ sejam zeros. Após a multiplicação e somatório, temos um zero na memória. Caso contrário, podemos manter a memória, ainda zerando a representação interna $ th $, mas mantendo um em $ f [t] $. Portanto, a soma obtém $ c [t-1] $ e continua sendo enviada. Finalmente, podemos escrever de forma que possamos obter um no portão de entrada, a multiplicação fica roxa e, em seguida, definir um zero no portão não se esqueça para que realmente esqueça. + + + +
+
+ Figura 25: Visualização da célula de memória +
+ + + +
+
+ Figura 26: Arquitetura LSTM - Redefinir memória +
+ + + +
+
+ Figura 27: Arquitetura LSTM - Manter memória +
+ + + +
+
+ Figura 28: Arquitetura LSTM - Memória de Gravação +
+ + + +## Exemplos de Notebook + + + +### Classificação de sequências (sequences) + + + +O objetivo é classificar as sequências. Elementos e destinos são representados localmente (vetores de entrada com apenas um bit diferente de zero). A sequência ** b ** egins com um `B`, ** e ** nds com um` E` (o “símbolo de gatilho”), e de outra forma consiste em símbolos escolhidos aleatoriamente do conjunto `{a, b, c , d} `exceto por dois elementos nas posições $ t_1 $ e $ t_2 $ que são` X` ou `Y`. Para o caso `DifficultyLevel.HARD`, o comprimento da sequência é escolhido aleatoriamente entre 100 e 110, $ t_1 $ é escolhido aleatoriamente entre 10 e 20, e $ t_2 $ é escolhido aleatoriamente entre 50 e 60. Existem 4 classes de sequência` Q `,` R`, `S` e` U`, que dependem da ordem temporal de `X` e` Y`. As regras são: `X, X -> Q`; `X, Y -> R`; `Y, X -> S`; `Y, Y -> U`. + + + +1). Exploração de conjunto de dados + + + +O tipo de retorno de um gerador de dados é uma tupla com comprimento 2. O primeiro item na tupla é o lote de sequências com forma $ (32, 9, 8) $. Esses são os dados que serão alimentados na rede. Existem oito símbolos diferentes em cada linha (`X`,` Y`, `a`,` b`, `c`,` d`, `B`,` E`). Cada linha é um vetor único. Uma sequência de linhas representa uma sequência de símbolos. A primeira linha totalmente zero é o preenchimento. Usamos preenchimento quando o comprimento da sequência é menor que o comprimento máximo do lote. O segundo item na tupla é o lote correspondente de rótulos de classe com forma $ (32, 4) $, uma vez que temos 4 classes (`Q`,` R`, `S` e` U`). A primeira sequência é: `BbXcXcbE`. Então, seu rótulo de classe decodificado é $ [1, 0, 0, 0] $, correspondendo a `Q`. + + + +
+
+ Figura 29: Exemplo de vetor de entrada +
+ + + +2). Definição do modelo e treinamento + + + +Vamos criar uma rede recorrente simples, um LSTM, e treinar por 10 períodos. No ciclo de treinamento, devemos sempre procurar cinco etapas: + + + +* Execute o passe para frente do modelo + * Calcule a perda + * Zere o cache de gradiente + * Backpropagate para calcular a derivada parcial de perda em relação aos parâmetros + * Pise na direção oposta do gradiente + + + +
+
+ Figura 30: RNN Simples *vs.* LSTM - 10 épocas +
+ + + +Com um nível de dificuldade fácil, RNN obtém 50% de precisão enquanto LSTM obtém 100% após 10 épocas. Mas LSTM tem quatro vezes mais pesos do que RNN e tem duas camadas ocultas, portanto, não é uma comparação justa. Após 100 épocas, o RNN também obtém 100% de precisão, levando mais tempo para treinar do que o LSTM. + + + +
+
+Figure 31: RNN Simples *vs.* LSTM - 100 Épocas +
+ + + +Se aumentarmos a dificuldade da parte de treinamento (usando sequências mais longas), veremos o RNN falhar enquanto o LSTM continua a funcionar. + + + +
+
+Figure 32: Visualização do valor do estado oculto +
+ + + +A visualização acima está desenhando o valor do estado oculto ao longo do tempo no LSTM. Enviaremos as entradas por meio de uma tangente hiperbólica, de forma que se a entrada estiver abaixo de $-2.5$, ela será mapeada para $-1$, e se estiver acima de $2,5$, será mapeada para $1$. Portanto, neste caso, podemos ver a camada oculta específica escolhida em `X` (quinta linha na imagem) e então ela se tornou vermelha até que obtivemos o outro` X`. Assim, a quinta unidade oculta da célula é acionada observando o `X` e fica quieta após ver o outro` X`. Isso nos permite reconhecer a classe de sequência. + + + +### Eco de sinal + + + +Ecoar o sinal n etapas é um exemplo de tarefa muitos-para-muitos sincronizada. Por exemplo, a 1ª sequência de entrada é `"1 1 0 0 1 0 1 1 0 0 0 0 0 0 0 0 1 1 1 1 ..."`, e a 1ª sequência de destino é `"0 0 0 1 1 0 0 1 0 1 1 0 0 0 0 0 0 0 0 1 ..."`. Nesse caso, a saída ocorre três etapas depois. Portanto, precisamos de uma memória de trabalho de curta duração para manter as informações. Já no modelo de linguagem, diz algo que ainda não foi dito. + + + +Antes de enviarmos toda a sequência para a rede e forçarmos o destino final a ser algo, precisamos cortar a sequência longa em pequenos pedaços. Ao alimentar um novo pedaço, precisamos acompanhar o estado oculto e enviá-lo como entrada para o estado interno ao adicionar o próximo novo pedaço. No LSTM, você pode manter a memória por muito tempo, desde que tenha capacidade suficiente. No RNN, depois de atingir um determinado comprimento, começa a esquecer o que aconteceu no passado. + diff --git a/docs/pt/week06/06.md b/docs/pt/week06/06.md new file mode 100644 index 000000000..6834deefc --- /dev/null +++ b/docs/pt/week06/06.md @@ -0,0 +1,36 @@ +--- +lang: pt +lang-ref: ch.06 +title: Semana 6 +translator: Bernardo Lago +--- + + + +## Aula parte A + +Discutimos três aplicações de redes neurais convolucionais. Começamos com o reconhecimento de dígitos e a aplicação para um reconhecimento de código postal (CEP) de 5 dígitos. Na detecção de objetos, falamos sobre como usar a arquitetura multi-escala em uma configuração de detecção de faces. Por último, vimos como ConvNets são usados em tarefas de segmentação semântica com exemplos concretos em um sistema de visão robótica e segmentação de objetos em um ambiente urbano. + + + +## Aula parte B + +Examinamos redes neurais recorrentes, seus problemas e técnicas comuns para mitigar esses problemas. Em seguida, revisamos uma variedade de módulos desenvolvidos para resolver os problemas do modelo RNN, incluindo Atenção (Attention), GRUs (Gated Recurrent Unit), LSTMs (Long Short-Term Memory) e Seq2Seq. + + + + +## Prática + +Discutimos a arquitetura dos modelos de RNN básica (vanilla) e LSTM e comparamos o desempenho entre os dois. O LSTM herda as vantagens do RNN, ao mesmo tempo em que melhora os pontos fracos do RNN ao incluir uma 'célula de memória' para armazenar informações na memória por longos períodos de tempo. Os modelos LSTM superam significativamente os modelos RNN. \ No newline at end of file diff --git a/docs/pt/week06/lecture06.sbv b/docs/pt/week06/lecture06.sbv new file mode 100644 index 000000000..a67ffa2f9 --- /dev/null +++ b/docs/pt/week06/lecture06.sbv @@ -0,0 +1,3338 @@ +0:00:04.960,0:00:08.970 +Então eu quero fazer duas coisas, falar sobre + +0:00:11.019,0:00:14.909 +Fale um pouco sobre como algumas maneiras de usar as Redes Convolucionais de várias maneiras + +0:00:16.119,0:00:18.539 +Que eu não passei da última vez + +0:00:19.630,0:00:21.630 +e + +0:00:22.689,0:00:24.689 +E eu também vou + +0:00:26.619,0:00:29.518 +Fale sobre os diferentes tipos de arquiteturas que + +0:00:30.820,0:00:33.389 +Alguns dos quais são muito recentemente projetados + +0:00:34.059,0:00:35.710 +que as pessoas foram + +0:00:35.710,0:00:40.320 +Tipo de jogar com por um bom tempo. Então vamos ver + +0:00:43.660,0:00:47.489 +Então, da última vez, quando falamos sobre Redes Convolucionais, paramos que o + +0:00:47.890,0:00:54.000 +ideia de que podemos usar Redes Convolucionais com um tipo de deslizamento que fazemos sobre imagens grandes e consiste em apenas + +0:00:54.550,0:00:56.550 +aplicando a convolução em imagens grandes + +0:00:57.070,0:01:01.559 +que é uma imagem muito geral, um método muito geral, então vamos + +0:01:03.610,0:01:06.900 +Veja mais algumas coisas sobre como usar redes convolucionais e + +0:01:07.659,0:01:08.580 +até certo ponto + +0:01:08.580,0:01:09.520 +eu vou + +0:01:09.520,0:01:16.020 +Confie em um pouco de papéis históricos e coisas assim para explicar formas simples de todas essas ideias + +0:01:17.409,0:01:21.269 +então como eu disse da última vez + +0:01:21.850,0:01:27.720 +Eu tive este exemplo onde há vários caracteres em uma imagem e você pode, você tem uma rede convolucional que + +0:01:28.360,0:01:32.819 +cuja saída também é uma convolução como o ar cotidiano é uma convolução para que você possa interpretar a saída como + +0:01:33.250,0:01:40.739 +basicamente dando-lhe uma pontuação para cada categoria e para cada janela na entrada e o enquadramento da janela depende + +0:01:41.860,0:01:47.879 +Como as janelas que o sistema observa quando seu projeto de volta para minha saída específica + +0:01:49.000,0:01:54.479 +Tipo de etapas pela quantidade de subamostragem da quantidade total de sub algo que você tem em uma rede + +0:01:54.640,0:01:59.849 +Então, se você tem duas camadas que subamostra por um fator de dois, você tem duas camadas de pool, por exemplo + +0:01:59.850,0:02:02.219 +Isso é um fator de dois no total + +0:02:02.920,0:02:07.199 +razão de subamostragem é 4 e o que isso significa é que cada saída é + +0:02:07.509,0:02:14.288 +Vou basicamente olhar para uma janela na entrada e as saídas sucessivas vão olhar para as janelas que são separadas por quatro pixels + +0:02:14.630,0:02:17.350 +Ok, é apenas um produto de todas as camadas de subamostragem + +0:02:20.480,0:02:21.500 +assim + +0:02:21.500,0:02:24.610 +isso é legal, mas então você vai ter que entender + +0:02:25.220,0:02:30.190 +Todas as coisas que estão na entrada. Como você escolhe objetos objetos que + +0:02:31.310,0:02:33.020 +sobrepor uns aos outros + +0:02:33.020,0:02:38.949 +Etc. E uma coisa que você pode fazer para isso é chamada de "supressão não máxima" + +0:02:41.180,0:02:43.480 +Que é o que as pessoas usam no tipo de detecção de objetos + +0:02:44.750,0:02:47.350 +então basicamente o que isso consiste é que se você tem + +0:02:49.160,0:02:53.139 +Saídas que estão mais ou menos no mesmo lugar e + +0:02:53.989,0:02:58.749 +ou também gosto de lugares sobrepostos e um deles diz que vejo um + +0:02:58.910,0:03:02.199 +Urso e o outro diz que vejo um cavalo que um deles ganha + +0:03:02.780,0:03:07.330 +Ok, provavelmente é um que está errado. E você não pode ter um urso em um cavalo ao mesmo tempo no mesmo lugar + +0:03:07.330,0:03:10.119 +Então você faz o que é chamado? Não, supressão máxima que você pode + +0:03:10.700,0:03:11.959 +Olha qual + +0:03:11.959,0:03:15.429 +qual deles tem a pontuação mais alta e você meio que escolhe esse ou vê se + +0:03:15.500,0:03:19.660 +quaisquer vizinhos também reconhecem isso como um urso ou um cavalo e você meio que faz um + +0:03:20.360,0:03:24.999 +votem se quiserem, voto local, ok, e vou detalhar isso porque + +0:03:25.760,0:03:28.719 +Apenas um tipo de ideias grosseiras. Bem, isso é + +0:03:29.930,0:03:34.269 +já implementado em código que você pode baixar e também é meio que o tópico de um + +0:03:35.030,0:03:37.509 +curso completo de visão computacional + +0:03:38.239,0:03:42.939 +Então, aqui, apenas aludimos a como usamos o aprendizado profundo para esse tipo de aplicativo + +0:03:46.970,0:03:48.970 +Vamos ver, então aqui está + +0:03:50.480,0:03:55.750 +Novamente voltando um pouco para a história algumas ideias de como você usa + +0:03:57.049,0:03:59.739 +redes neurais para ou redes convolucionais neste caso para + +0:04:00.500,0:04:04.690 +Reconhecer strings de caracteres que é meio que o mesmo programa que reconhece vários objetos, realmente + +0:04:05.450,0:04:12.130 +Então, se você tiver, você tem uma imagem que contém a imagem no topo... "dois, três dois, zero, seis" + +0:04:12.130,0:04:15.639 +É um código postal e os caracteres se tocam para que você não saiba separá-los com antecedência + +0:04:15.979,0:04:22.629 +Então você apenas aplica uma rede convolucional a toda a string, mas não sabe de antemão qual a largura que os caracteres terão e assim + +0:04:24.500,0:04:30.739 +o que você vê aqui são quatro conjuntos diferentes de saídas e esses quatro conjuntos diferentes de saídas de + +0:04:31.170,0:04:33.170 +a rede convolucional + +0:04:33.300,0:04:36.830 +Cada uma delas tem dez linhas e as dez palavras correspondem a cada uma das dez categorias + +0:04:38.220,0:04:43.489 +então se você olhar para o topo, por exemplo, o topo, o bloco superior + +0:04:44.220,0:04:46.940 +os quadrados brancos representam categorias de alta pontuação + +0:04:46.940,0:04:53.450 +Então, o que você vê à esquerda é que o número dois está sendo reconhecido. Assim, a janela que é vista pelo + +0:04:54.120,0:04:59.690 +As unidades de saída que estão na primeira coluna estão no lado esquerdo da imagem e ela detecta duas + +0:05:00.330,0:05:03.499 +Porque você sabe o pedido deles 0 1 2 3 4 etc + +0:05:03.810,0:05:07.160 +Então você vê um quadrado branco que corresponde à detecção de um 2 + +0:05:07.770,0:05:09.920 +e então como a janela é + +0:05:11.400,0:05:13.400 +deslocado sobre o, sobre a entrada + +0:05:14.310,0:05:19.549 +É um 3 ou 3 de pontuação baixa que é visto, então o 2 novamente há três caracteres + +0:05:19.550,0:05:24.980 +São três detectores que veem esse 2 e depois nada, depois o 0 e depois o 6 + +0:05:26.670,0:05:28.670 +Agora este primeiro + +0:05:29.580,0:05:32.419 +O sistema olha para uma janela bastante estreita e + +0:05:35.940,0:05:40.190 +Ou talvez seja uma janela larga não, eu acho que é uma janela larga então ela olha para uma janela bem larga e + +0:05:41.040,0:05:42.450 +isto + +0:05:42.450,0:05:44.450 +quando olha para o, o + +0:05:45.240,0:05:50.030 +Os dois, os dois que estão à esquerda por exemplo, na verdade vê um pedaço dos três com ele, com ele + +0:05:50.030,0:05:55.459 +Então é meio que na janela os diferentes conjuntos de saídas aqui correspondem a tamanhos diferentes + +0:05:55.830,0:06:01.009 +Do kernel da última camada. Então a segunda linha o segundo bloco + +0:06:01.890,0:06:05.689 +O tamanho do kernel é quatro na dimensão horizontal + +0:06:07.590,0:06:11.869 +O próximo é 3 e o próximo é 2. o que isso permite que o sistema faça é olhar para + +0:06:13.380,0:06:19.010 +Regiões de várias larguras na entrada sem ficar meio confuso com os caracteres que estão na lateral se quiser + +0:06:19.500,0:06:20.630 +então por exemplo + +0:06:20.630,0:06:28.189 +o, o, o segundo a zero é uma pontuação muito alta no, no, no + +0:06:29.370,0:06:36.109 +Segundo terceiro e quarto mapa, mas não com pontuação muito alta no mapa superior. Da mesma forma, o três é uma espécie de pontuação alta no + +0:06:37.020,0:06:38.400 +segundo terceiro e quarto mapa + +0:06:38.400,0:06:41.850 +mas não no primeiro mapa porque os três tipos de sobreposição com os dois e assim + +0:06:42.009,0:06:45.059 +Ele quer realmente olhar em nossa janela para poder reconhecê-lo + +0:06:45.639,0:06:47.639 +OK. sim + +0:06:51.400,0:06:55.380 +Então é o tamanho do quadrado branco que indica a pontuação basicamente, ok + +0:06:57.759,0:07:02.038 +Então olhe para você sabe, esta coluna aqui você tem uma pontuação alta zero + +0:07:03.009,0:07:06.179 +Aqui porque é o primeiro a primeira linha corresponde à categoria zero + +0:07:06.430,0:07:10.079 +mas não é tão alta pontuação do topo, o melhor porque isso + +0:07:10.539,0:07:15.419 +unidade de saída olha para uma entrada bastante ampla e fica confusa com as coisas que estão ao lado + +0:07:16.479,0:07:17.910 +Ok, então você tem algo assim + +0:07:17.910,0:07:23.579 +então agora você tem que entender isso e extrair a melhor interpretação disso, dessa sequência e + +0:07:24.760,0:07:31.349 +É verdade para o código postal, mas é verdade para quase todos os pedaços de texto. Nem todas as combinações de caracteres são possíveis + +0:07:31.599,0:07:36.149 +então, quando você lê um texto em inglês, há, você sabe, um dicionário de inglês, gramática inglesa e + +0:07:36.699,0:07:40.919 +Nem todas as combinações de caracteres são possíveis, então você pode ter um modelo de linguagem que + +0:07:41.470,0:07:42.610 +tentativas de + +0:07:42.610,0:07:48.720 +Diga-lhe qual é a sequência de caracteres mais provável. Então, estamos olhando aqui dado que isso é inglês ou qualquer outro idioma + +0:07:49.510,0:07:54.929 +Ou dado que este é um código postal, nem todos os códigos postais são possíveis. Então esta --- possibilidade de correção de erros + +0:07:56.949,0:08:00.719 +Então, como levamos isso em consideração? Eu vou chegar a isso em um segundo, mas + +0:08:03.460,0:08:06.930 +Mas aqui o que precisamos fazer é meio que você sabe + +0:08:08.169,0:08:10.169 +Crie uma interpretação consistente + +0:08:10.389,0:08:15.809 +Que você sabe, obviamente há um três, obviamente há um dois, um três, um zero em algum lugar + +0:08:16.630,0:08:19.439 +Outros dois etc. Como devolver isso + +0:08:20.110,0:08:22.710 +matriz de pontuações em, em um consistente + +0:08:23.470,0:08:25.470 +interpretação + +0:08:28.610,0:08:31.759 +É a largura do, a largura horizontal do, + +0:08:33.180,0:08:35.180 +o kernel da última camada + +0:08:35.400,0:08:36.750 +OK + +0:08:36.750,0:08:44.090 +O que significa que quando você faz backprop ---, projeta de volta na entrada, a janela de visualização na entrada que influencia essa unidade específica + +0:08:44.550,0:08:48.409 +tem vários tamanhos dependendo de qual unidade você olha. sim + +0:08:52.500,0:08:54.500 +A largura do bloco sim + +0:08:56.640,0:08:58.070 +É um, corresponde + +0:08:58.070,0:08:58.890 +é quão largo o + +0:08:58.890,0:09:05.090 +A imagem de entrada é dividida por 4 porque o problema substantivo é 4, então você obtém uma de uma coluna para cada quatro pixels + +0:09:05.340,0:09:11.660 +então lembre-se que tínhamos isso, essa maneira de usar uma rede neural, rede convolucional que é que você basicamente faz cada + +0:09:12.240,0:09:17.270 +Convolução maior e você visualiza a última camada como uma convolução também. E agora o que você obtém é múltiplo + +0:09:17.790,0:09:23.119 +Saídas. OK. Então, o que estou representando aqui no slide que você acabou de ver + +0:09:23.760,0:09:30.470 +é o, é este array 2d na saída que corresponde onde, onde a, a linha corresponde às categorias + +0:09:31.320,0:09:35.030 +Ok, e cada coluna corresponde a um local diferente na entrada + +0:09:39.180,0:09:41.750 +E eu te mostrei esses exemplos aqui então + +0:09:42.300,0:09:50.029 +Aqui, esta é uma representação diferente aqui onde o caractere que é exibido logo antes da barra de título é que você conhece + +0:09:50.030,0:09:56.119 +Indica a categoria vencedora, portanto não estou exibindo as pontuações de todas as categorias. Estou apenas, apenas, apenas exibindo a categoria vencedora aqui + +0:09:57.180,0:09:58.260 +mas cada + +0:09:58.260,0:10:04.640 +A saída olha para uma janela de 32 por 32 e a próxima saída olha para uma janela de 32 por 32 deslocada por 4 pixels + +0:10:04.650,0:10:06.650 +Tudo bem, etc + +0:10:08.340,0:10:14.809 +Então, como você transforma essa sequência de caracteres no fato de que é 3 5 ou 5 3 + +0:10:29.880,0:10:33.979 +Ok, então aqui a razão pela qual temos quatro desses é porque o último jogador + +0:10:34.800,0:10:36.270 +isso diferente + +0:10:36.270,0:10:42.889 +São últimas camadas diferentes, se você quiser essas quatro últimas camadas diferentes, cada uma delas treinada para reconhecer as dez categorias + +0:10:43.710,0:10:50.839 +E essas últimas camadas têm larguras de kernel diferentes, então elas essencialmente olham para larguras diferentes do Windows na entrada + +0:10:53.670,0:10:59.510 +Então você quer alguns que olhem para janelas largas para que possam reconhecer tipos de caracteres grandes e alguns que olhem, olhem + +0:10:59.510,0:11:02.119 +Em janelas estreitas para que possam reconhecer caracteres estreitos sem serem + +0:11:03.210,0:11:05.210 +perturbado pelos personagens vizinhos + +0:11:09.150,0:11:14.329 +Então, se você sabe a priori que há cinco cinco caracteres aqui porque é um código postal + +0:11:16.529,0:11:18.529 +Você pode fazer você pode usar um truque e + +0:11:20.010,0:11:22.010 +Existem alguns truques específicos que + +0:11:23.130,0:11:27.140 +Eu posso explicar, mas vou explicar o truque geral, se você quiser. eu + +0:11:27.959,0:11:30.619 +Na verdade não queria falar sobre isso, pelo menos não agora + +0:11:31.709,0:11:37.729 +Ok, aqui está um truque geral, o truque geral é ou o que você sabe, um truque um pouco específico + +0:11:38.370,0:11:40.609 +Opa, não sei como continua mudando de slide + +0:11:43.890,0:11:50.809 +Você diz que eu tenho eu sei que tenho cinco caracteres nesta palavra, há um + +0:11:57.990,0:12:01.760 +Essa é uma daquelas matrizes que produz pontuações para cada categoria + +0:12:03.060,0:12:07.279 +Digamos que eu tenha quatro categorias aqui e cada local + +0:12:11.339,0:12:18.049 +Há uma pontuação, ok e digamos que eu sei que quero cinco caracteres + +0:12:20.250,0:12:27.469 +Vou desenhá-los verticalmente um dois, três, quatro cinco porque é um código postal + +0:12:29.579,0:12:34.279 +Então, a pergunta que vou fazer agora é qual é o melhor personagem que posso colocar nisso e + +0:12:35.220,0:12:37.220 +Neste slot no primeiro slot + +0:12:38.699,0:12:43.188 +E o jeito que vou fazer isso é desenhar um array + +0:12:48.569,0:12:50.569 +E nesta matriz + +0:12:54.120,0:13:01.429 +Eu vou dizer qual é a pontuação aqui, em cada interseção na matriz? + +0:13:07.860,0:13:11.659 +Vai ser, qual é, qual é a pontuação de colocar + +0:13:12.269,0:13:17.899 +Um personagem em particular aqui nesse local, dada a pontuação que tenho na saída da minha rede neural + +0:13:19.560,0:13:21.560 +Ok, então vamos dizer que + +0:13:24.480,0:13:28.159 +Então o que eu vou ter que decidir é que eu tenho menos personagens + +0:13:29.550,0:13:32.539 +Na saída para o sistema cinco + +0:13:33.329,0:13:39.919 +Então tenho janelas de visualização e partituras produzidas pelo sistema. Eu vou ter que descobrir qual eu derrubo + +0:13:40.949,0:13:42.949 +tudo bem e + +0:13:43.860,0:13:47.689 +O que posso fazer é construir isso, construir este array + +0:13:55.530,0:13:57.530 +E + +0:14:01.220,0:14:09.010 +O que eu preciso fazer é ir daqui até aqui encontrando um caminho através deste array + +0:14:15.740,0:14:17.859 +De tal forma que eu tenho exatamente cinco + +0:14:20.420,0:14:24.640 +Passos se você quiser, então cada passo corresponde a um personagem e + +0:14:25.790,0:14:31.630 +a pontuação geral de uma determinada sequência é a geral é a soma de todas as pontuações que + +0:14:33.050,0:14:37.060 +Estão nesse caminho, em outras palavras, se eu conseguir + +0:14:39.560,0:14:41.560 +Três + +0:14:41.930,0:14:47.890 +Instâncias aqui, três locais onde tenho uma pontuação alta para essa categoria específica, que é a categoria um. Ok, vamos chamá-lo de 0 + +0:14:48.440,0:14:50.440 +Então 1 2 3 + +0:14:51.140,0:14:54.129 +Eu vou dizer que este é o mesmo cara e é um 1 + +0:14:55.460,0:14:57.460 +e aqui se eu tiver + +0:14:58.160,0:15:03.160 +Dois rapazes. Eu tenho pontuação alta para 3, vou dizer que esses são os 3 e aqui + +0:15:03.160,0:15:08.800 +Eu tenho apenas um cara que tem pontuação alta para 2. Então isso é um 2 etc. + +0:15:11.930,0:15:13.370 +assim + +0:15:13.370,0:15:15.880 +Esse caminho aqui tem que ser meio contínuo + +0:15:16.580,0:15:23.080 +Eu não posso pular de uma posição para outra porque isso seria meio que quebrar a ordem dos personagens. OK? + +0:15:24.650,0:15:31.809 +E preciso encontrar um caminho que passe pelas células de alta pontuação, se você quiser que corresponda a + +0:15:33.500,0:15:36.489 +Categorias de alta pontuação ao longo deste caminho e é uma forma de + +0:15:37.190,0:15:39.190 +dizendo que você sabe se eu tenho + +0:15:39.950,0:15:43.150 +se essas três células aqui ou + +0:15:44.000,0:15:47.530 +Dê-me o mesmo personagem. É apenas um personagem. só vou dar saída + +0:15:48.440,0:15:50.799 +Um aqui que corresponde a este + +0:15:51.380,0:15:57.189 +Ok, esses três caras têm pontuação alta. Eu fico no um, no um e então faço a transição + +0:15:57.770,0:16:02.379 +Para o segundo personagem. Então agora eu vou preencher essa vaga e esse cara tem pontuação alta por três + +0:16:02.750,0:16:06.880 +Então eu vou colocar três aqui e esse cara tem uma pontuação alta para dois + +0:16:07.400,0:16:08.930 +como dois + +0:16:08.930,0:16:10.930 +etc. + +0:16:14.370,0:16:19.669 +O princípio para encontrar este caminho é um algoritmo de caminho mais curto + +0:16:19.670,0:16:25.190 +Você pode pensar nisso como um gráfico onde eu posso ir da célula inferior esquerda para a célula superior direita + +0:16:25.560,0:16:27.560 +Ou indo para a esquerda + +0:16:28.410,0:16:32.269 +ou subindo e para a esquerda e + +0:16:35.220,0:16:38.660 +Para cada uma dessas transições há um custo e para cada uma das + +0:16:39.060,0:16:45.169 +Para colocar um personagem nesse local, também há um custo ou uma pontuação, se você quiser + +0:16:47.460,0:16:49.460 +Então o geral + +0:16:50.700,0:16:57.049 +A pontuação do que está na parte inferior seria a pontuação combinada dos três locais que detectam aquele e + +0:16:59.130,0:17:01.340 +Porque é mais que todos os três são + +0:17:02.730,0:17:04.730 +contribuindo com evidências para o fato de que existe um 1 + +0:17:06.720,0:17:08.959 +Quando você restringe o caminho para ter 5 passos + +0:17:10.530,0:17:14.930 +Ok, tem que ir do canto inferior esquerdo para o canto superior direito e + +0:17:15.930,0:17:18.169 +Tem 5 passos, então tem que passar por 5 passos + +0:17:18.750,0:17:24.290 +Não há escolha. É assim que você força o sistema a fornecer basicamente 5 caracteres, certo? + +0:17:24.810,0:17:28.909 +E porque o caminho só pode ir da esquerda para a direita e de cima para baixo + +0:17:30.330,0:17:33.680 +Ele deve fornecer os caracteres na ordem em que aparecem na imagem + +0:17:34.350,0:17:41.240 +Então é uma forma de impor a ordem do caractere e impor que são cincos, são cinco caracteres na string. sim + +0:17:42.840,0:17:48.170 +Sim, tudo bem na parte de trás, sim, certo. sim + +0:17:52.050,0:17:55.129 +Bem, então se tivermos apenas a seqüência de um você tem que ter + +0:17:55.680,0:18:02.539 +Treinou o sistema com antecedência para que, quando estiver entre dois ou dois personagens, sejam eles quais forem, não diga nada + +0:18:02.540,0:18:04.540 +não diz nenhuma das opções acima + +0:18:04.740,0:18:06.740 +Caso contrário, você pode dizer, certo + +0:18:07.140,0:18:11.359 +Sim, um sistema como esse precisa ser capaz de dizer que isso não é nenhuma das opções acima. Não é um personagem + +0:18:11.360,0:18:16.160 +É um pedaço disso ou estou no meio de dois personagens ou tenho dois personagens ao lado + +0:18:16.160,0:18:17.550 +Mas nada no meio + +0:18:17.550,0:18:19.550 +Sim, absolutamente + +0:18:24.300,0:18:26.300 +É uma forma de supressão não máxima + +0:18:26.300,0:18:31.099 +então você pode pensar nisso como uma forma inteligente de supressão não máxima, onde você diz como para cada local que você só pode + +0:18:31.100,0:18:31.950 +tem um + +0:18:31.950,0:18:33.950 +personagem + +0:18:33.990,0:18:40.370 +E a ordem em que você produz os cinco caracteres deve corresponder à ordem em que eles aparecem na imagem + +0:18:41.640,0:18:47.420 +O que você não sabe é como deformar um no outro. OK. Então, como você sabe, quantos + +0:18:48.210,0:18:53.780 +os detectores vão ver o número dois. Pode ser três deles e vamos decidir que são todos iguais + +0:19:00.059,0:19:02.748 +Então a coisa é para todos vocês que + +0:19:03.629,0:19:06.469 +estão em ciência da computação, que não é todo mundo + +0:19:07.590,0:19:12.379 +A maneira como você calcula esse caminho é apenas um algoritmo de caminho mais curto. Você faz isso com programação dinâmica + +0:19:13.499,0:19:15.090 +OK + +0:19:15.090,0:19:21.350 +então encontre o caminho mais curto para ir do canto inferior esquerdo ao canto superior direito, passando por apenas indo para + +0:19:22.080,0:19:25.610 +apenas fazendo transição para a direita ou diagonalmente e + +0:19:26.369,0:19:28.369 +minimizando o + +0:19:28.830,0:19:31.069 +custo, então se você acha que cada um desses + +0:19:31.710,0:19:38.659 +É preenchido por um custo ou maximizando a pontuação se você acha que as pontuações existem probabilidades, por exemplo + +0:19:38.789,0:19:41.479 +E é apenas um algoritmo de caminho mais curto em um gráfico + +0:19:54.840,0:19:56.840 +Esse tipo de método, aliás, foi + +0:19:57.090,0:20:04.730 +Muitos métodos iniciais de reconhecimento de fala funcionam dessa maneira, mas não com redes neurais. Nós meio que extraímos recursos de + +0:20:05.909,0:20:13.189 +mas basicamente combinaria a sequência de vetores extraída de um sinal de fala para um modelo de uma palavra e então você + +0:20:13.409,0:20:17.809 +sei tentar ver como você distorce o tempo para combinar com o + +0:20:19.259,0:20:24.559 +A palavra a ser reconhecida para os modelos e você tinha um modelo para cada palavra em tamanho fixo + +0:20:25.679,0:20:32.569 +Isso foi chamado de DTW, trabalho de tempo dinâmico. Existe uma versão mais sofisticada chamada de modelos ocultos de markov, mas é muito semelhante + +0:20:33.600,0:20:35.600 +As pessoas ainda fazem isso até certo ponto + +0:20:43.000,0:20:44.940 +OK + +0:20:44.940,0:20:49.880 +Então detecção, então se você quiser aplicar rede comercial para detecção + +0:20:50.820,0:20:55.380 +funciona incrivelmente bem e é surpreendentemente simples, mas você + +0:20:56.020,0:20:57.210 +Você sabe o que você precisa fazer + +0:20:57.210,0:20:59.210 +Você basicamente precisa dizer que quer fazer a detecção de rosto + +0:20:59.440,0:21:05.130 +Que é um problema muito fácil um dos primeiros problemas que a visão computacional começou a resolver muito bem para o tipo de reconhecimento + +0:21:05.500,0:21:07.500 +você coleta um conjunto de dados de + +0:21:08.260,0:21:11.249 +imagens com rostos e imagens sem rostos e + +0:21:12.160,0:21:13.900 +você treina um + +0:21:13.900,0:21:19.379 +rede convolucional com janela de entrada em algo como 20 por 20 ou 30 por 30 pixels? + +0:21:19.870,0:21:21.959 +Para dizer se há um rosto nele ou não + +0:21:22.570,0:21:28.620 +OK. Agora você pega essa rede convolucional, aplica em uma imagem e se houver um rosto que seja aproximadamente + +0:21:29.230,0:21:31.230 +30 por 30 pixels o + +0:21:31.809,0:21:35.699 +o conteúdo acenderá na saída correspondente e + +0:21:36.460,0:21:38.460 +Não acende quando não há rosto + +0:21:39.130,0:21:41.999 +agora há dois problemas com isso, o primeiro problema é + +0:21:42.940,0:21:47.370 +há muitas maneiras pelas quais um pedaço de uma imagem pode ser um não rosto e + +0:21:48.130,0:21:53.489 +Durante seu treinamento, você provavelmente não viu todos eles. Você não viu nem mesmo um conjunto representativo deles + +0:21:53.950,0:21:56.250 +Então seu sistema vai ter muitos falsos positivos + +0:21:58.390,0:22:04.709 +Esse é o primeiro problema. O segundo problema é que na foto nem todos os rostos têm 30 por 30 pixels. Então, como você lida + +0:22:05.380,0:22:10.229 +Variação de tamanho, uma maneira de lidar com a variação de tamanho, que é muito simples + +0:22:10.230,0:22:14.010 +mas é principalmente desnecessário em versões modernas, bem + +0:22:14.860,0:22:16.860 +pelo menos não é totalmente necessário + +0:22:16.929,0:22:22.499 +Você faz uma abordagem multiescala. Então você pega sua imagem e roda seu detector nela. Ele dispara quando quer + +0:22:23.440,0:22:27.299 +E você detectará que os rostos são pequenos e reduzirá a imagem por + +0:22:27.850,0:22:30.179 +Alguma escala neste caso, neste caso aqui + +0:22:30.179,0:22:31.419 +eu tiro uma raiz quadrada de dois + +0:22:31.419,0:22:36.599 +Você aplica a rede convolucional novamente nessa imagem menor e agora ela será capaz de detectar faces que são + +0:22:38.350,0:22:45.750 +Isso era maior na imagem original porque agora o que era 30 por 30 pixels agora é cerca de 20 por 20 pixels, aproximadamente + +0:22:47.169,0:22:48.850 +OK + +0:22:48.850,0:22:53.309 +Mas pode haver rostos maiores lá. Então você dimensiona a imagem novamente por um fator de raiz quadrada de 2 + +0:22:53.309,0:22:57.769 +Então agora as imagens do tamanho da original e você executa a rede convolucional novamente + +0:22:57.770,0:23:01.070 +E agora vai detectar rostos que tinham 60 por 60 pixels + +0:23:02.190,0:23:06.109 +Na imagem original, mas agora são 30 por 30 porque você reduz o tamanho pela metade + +0:23:07.800,0:23:10.369 +Você pode pensar que isso é caro, mas não é. O + +0:23:11.220,0:23:15.439 +despesa é, metade da despesa é a escala final + +0:23:16.080,0:23:18.379 +a soma das despesas das outras redes são + +0:23:19.590,0:23:21.859 +Combinado é aproximadamente o mesmo que a escala final + +0:23:26.070,0:23:29.720 +É porque o tamanho da rede é que você sabe + +0:23:29.720,0:23:33.019 +Tipo do quadrado do tamanho da imagem de um lado + +0:23:33.020,0:23:38.570 +E assim você reduz a imagem pela raiz quadrada de 2, a rede que você precisa executar é menor por um fator de 2 + +0:23:40.140,0:23:45.619 +Ok, então o custo total disso é 1 mais 1/2 mais 1/4 mais 1/8 mais 1/16 etc + +0:23:45.990,0:23:51.290 +Que é 2 você desperdiça um fator de 2 fazendo multi-escala, o que é muito pequeno. OK + +0:23:51.290,0:23:53.290 +você pode pagar um fator de 2, então + +0:23:54.570,0:23:59.600 +Este é um sistema de detecção de rosto completamente antigo do início dos anos 90 e + +0:24:00.480,0:24:02.600 +os mapas que você vê aqui são todos do tipo + +0:24:03.540,0:24:05.540 +mapas que indicam o tipo de + +0:24:06.120,0:24:13.160 +Dezenas de detectores de rosto, o detector de rosto aqui eu acho que é de 20 por 20 pixels. Então é muito baixa resolução e + +0:24:13.890,0:24:19.070 +É uma grande confusão nas escalas finas. Você vê áreas de alta pontuação, mas não é realmente muito definido + +0:24:19.710,0:24:21.710 +Mas você vê mais + +0:24:22.530,0:24:24.150 +Mais definido + +0:24:24.150,0:24:26.720 +Coisas aqui embaixo. Então aqui você vê + +0:24:27.780,0:24:33.290 +Uma mancha branca aqui, uma mancha branca aqui, uma mancha branca aqui mesmo aqui. Você vê bolha branca aqui, bolha branca aqui e + +0:24:34.020,0:24:35.670 +Esses são rostos + +0:24:35.670,0:24:41.060 +e agora é assim que você precisa fazer a supressão máxima para obter esses + +0:24:41.580,0:24:46.489 +pequenos quadrados vermelhos que são as categorias vencedoras se você quiser os locais vencedores onde você tem um rosto + +0:24:50.940,0:24:52.470 +assim + +0:24:52.470,0:24:57.559 +Conhecido como supressão de sumô neste caso, significa que tenho uma bolha branca branca de alta pontuação aqui + +0:24:57.560,0:25:01.340 +Isso significa que provavelmente há o rosto embaixo, que tem aproximadamente 20 por 20 + +0:25:01.370,0:25:06.180 +É outro rosto em uma janela de 20 por 20. Isso significa que um desses dois está errado + +0:25:06.250,0:25:10.260 +então eu vou pegar o de maior pontuação dentro da janela de 20 por 20 e + +0:25:10.600,0:25:15.239 +Suprima todos os outros e você suprimirá os outros naquele local nessa escala + +0:25:15.240,0:25:22.410 +Refiro-me a esse local próximo nessa escala, mas também em outras escalas. Ok, então você escolhe a pontuação mais alta + +0:25:23.680,0:25:25.680 +blob se você quiser + +0:25:26.560,0:25:28.560 +Para cada local cada escala + +0:25:28.720,0:25:34.439 +E sempre que você escolhe um, você suprime os outros que podem estar em conflito com ele. + +0:25:34.780,0:25:37.259 +porque eles são uma escala diferente no mesmo lugar ou + +0:25:37.960,0:25:39.960 +Na mesma escala, mas você sabe nas proximidades + +0:25:44.350,0:25:46.350 +Ok, então esse é o + +0:25:46.660,0:25:53.670 +esse é o primeiro problema e o segundo problema é o fato de que, como eu disse, há muitas maneiras de ser diferente do seu rosto e + +0:25:54.730,0:25:59.820 +Muito provavelmente seu conjunto de treinamento não tem todos os não rostos, coisas que parecem rostos + +0:26:00.790,0:26:05.249 +Então, a maneira como as pessoas lidam com isso é que eles fazem o que é chamado de mineração negativa + +0:26:05.950,0:26:07.390 +assim + +0:26:07.390,0:26:09.390 +Você passa por uma grande coleção de imagens + +0:26:09.460,0:26:14.850 +quando você sabe de fato que não há rosto e você executa seu detector e mantém todos os + +0:26:16.720,0:26:19.139 +Patches onde você detecta disparos + +0:26:21.190,0:26:26.580 +Você verifica se não há rostos neles e, se não houver rosto, você os adiciona ao seu conjunto negativo + +0:26:27.610,0:26:31.830 +Ok, então você retreinar seu detector. E então você usa seu detector treinado para fazer o mesmo + +0:26:31.990,0:26:35.580 +Vá novamente por um grande conjunto de dados de imagens onde você conhece + +0:26:35.580,0:26:40.710 +Não há rosto e sempre que seu detector disparar adicione isso como uma amostra negativa + +0:26:41.410,0:26:43.410 +você faz isso quatro ou cinco vezes e + +0:26:43.840,0:26:50.129 +No final você tem um detector de rosto muito robusto que não é vítima de amostras negativas + +0:26:53.080,0:26:56.669 +Estas são todas as coisas que parecem rostos em imagens naturais não são rostos + +0:27:03.049,0:27:05.049 +Isso funciona muito bem + +0:27:10.380,0:27:17.209 +Este é um trabalho de mais de 15 anos, este é o casamento dos meus avós, o casamento deles + +0:27:18.480,0:27:20.480 +o casamento deles + +0:27:22.410,0:27:24.410 +OK + +0:27:24.500,0:27:29.569 +Então aqui está outro uso interessante de redes convolucionais e isso é para + +0:27:30.299,0:27:34.908 +Segmentação semântica o que é chamado de segmentação semântica, eu fiz alusão a isso na primeira aula + +0:27:36.390,0:27:44.239 +então o que é segmentação semântica é o problema de atribuir uma categoria a cada pixel em uma imagem e + +0:27:46.020,0:27:49.280 +Cada pixel será rotulado com uma categoria do objeto ao qual pertence + +0:27:50.250,0:27:55.429 +Então imagine que isso seria muito útil se você quiser dizer dirigir um robô na natureza. Então isso é um + +0:27:56.039,0:28:00.769 +Projeto de robótica em que trabalhei, meus alunos e eu trabalhamos há muito tempo + +0:28:01.770,0:28:07.520 +E o que você gosta é de rotular a imagem para que as regiões em que o robô possa dirigir + +0:28:08.820,0:28:10.820 +são indicados e + +0:28:10.860,0:28:15.199 +As áreas que são obstáculos também são indicadas para que o robô não dirija até lá. OK + +0:28:15.200,0:28:22.939 +Então aqui as áreas verdes são coisas sobre as quais o robô pode dirigir e as áreas vermelhas são obstáculos como grama alta nesse caso + +0:28:28.049,0:28:34.729 +Então, a maneira como você treina uma rede convolucional para fazer esse tipo de segmentação semântica é muito semelhante ao que acabei de + +0:28:35.520,0:28:38.659 +Descrito você você pega um patch da imagem + +0:28:39.360,0:28:41.360 +Nesse caso. acho que os remendos foram + +0:28:42.419,0:28:44.719 +20 por 40 ou algo assim, eles são realmente pequenos + +0:28:46.080,0:28:51.860 +Para qual, você sabe o que é o pixel central, se é percorrível ou não, se é verde ou vermelho? + +0:28:52.470,0:28:56.390 +ok, ou está sendo rotulado manualmente ou o rótulo foi obtido de alguma forma e + +0:28:57.570,0:29:00.110 +Você executa uma rede de conversão neste patch e treina, você sabe + +0:29:00.110,0:29:02.479 +me diga se é se ele é verde ou vermelho me diga se é + +0:29:03.000,0:29:05.000 +Área transitável ou não + +0:29:05.970,0:29:09.439 +E uma vez que o sistema é treinado você aplica na imagem inteira e você sabe + +0:29:09.440,0:29:14.540 +Coloca verde ou vermelho dependendo de onde está. neste caso em particular, na verdade, havia cinco categorias + +0:29:14.830,0:29:18.990 +Há o super verde verde roxo, que é um pé de um objeto + +0:29:19.809,0:29:24.269 +Vermelho, que é um obstáculo que você sabe que jogou fora e super vermelho, que é como um obstáculo definitivo + +0:29:25.600,0:29:30.179 +Por aqui. Estamos mostrando apenas três três cores agora neste particular + +0:29:31.809,0:29:37.319 +Projete se os rótulos foram realmente coletados automaticamente, você não precisou manualmente + +0:29:39.160,0:29:44.160 +Rotule as imagens e os patches, o que fazemos seria rodar o robô e depois + +0:29:44.890,0:29:49.379 +através da visão estéreo descobrir se um pixel é um + +0:29:51.130,0:29:53.669 +Corresponde a um objeto que sai do chão ou está no chão + +0:29:55.540,0:29:59.309 +A coluna do meio aqui diz rótulos estéreo que são + +0:30:00.309,0:30:05.789 +Rótulos, para que a cor verde ou vermelha seja calculada a partir da visão estéreo da reconstrução basicamente 3D + +0:30:06.549,0:30:08.639 +ok, então, você tem duas câmeras e + +0:30:09.309,0:30:15.659 +As duas câmeras podem estimar a distância de cada pixel basicamente comparando patches. É relativamente caro, mas funciona + +0:30:15.730,0:30:17.819 +Não é totalmente confiável, mas funciona + +0:30:18.820,0:30:21.689 +Então agora para cada pixel você tem uma profundidade a distância da câmera + +0:30:22.360,0:30:25.890 +O que significa que você sabe a posição desse pixel em 3d, o que significa que você sabe + +0:30:25.890,0:30:30.030 +Se sair do chão ou se estiver no chão, porque você pode encaixar um avião no chão + +0:30:30.880,0:30:33.900 +ok, então os pixels verdes são os que são basicamente + +0:30:34.450,0:30:37.980 +Você sabe perto do chão e os vermelhos são os que estão em cima + +0:30:39.280,0:30:42.479 +então agora você tem rótulos que você pode tentar e realizar para + +0:30:43.330,0:30:44.919 +prever esses rótulos + +0:30:44.919,0:30:49.529 +Então você vai me dizer por que você quer treinar uma rede convolucional para fazer isso se você pode fazer isso em estéreo? + +0:30:50.260,0:30:53.760 +E a resposta é estéreo só funciona até dez metros, aproximadamente + +0:30:54.669,0:30:59.789 +Depois de dez metros você não pode realmente usar visão binocular e visão estéreo, você não pode realmente estimar a distância muito bem + +0:30:59.790,0:31:04.799 +E isso só funciona até cerca de dez metros e dirigir um robô apenas olhando + +0:31:05.200,0:31:07.770 +dez metros à sua frente não é uma boa ideia + +0:31:08.950,0:31:13.230 +É como dirigir um carro no meio do nevoeiro, certo? Vai não é muito eficiente + +0:31:14.380,0:31:21.089 +Então, o que você costumava fazer era rotular cada pixel na imagem até o horizonte + +0:31:21.790,0:31:23.790 +essencialmente + +0:31:24.130,0:31:30.239 +Ok, então o legal desse sistema é que, como eu disse, os rótulos eram coletados automaticamente, mas também + +0:31:32.080,0:31:33.730 +O robô + +0:31:33.730,0:31:38.849 +Adaptou-se à medida que corre porque coleciona rótulos estéreo constantemente + +0:31:39.340,0:31:43.350 +Ele pode treinar constantemente sua rede neural para se adaptar ao ambiente + +0:31:43.360,0:31:49.199 +está dentro. Nesta instância específica deste robô, ele apenas treinará novamente a última camada + +0:31:49.540,0:31:53.879 +Então as camadas N menos 1 do ConvNet foram corrigidas, foram treinadas no laboratório + +0:31:53.880,0:32:01.499 +E então a última camada foi meio que adaptada à medida que o robô funcionava, permitindo que o robô lidasse com ambientes + +0:32:01.500,0:32:02.680 +Ele nunca tinha visto antes + +0:32:02.680,0:32:04.120 +essencialmente + +0:32:04.120,0:32:06.120 +Você ainda tem visão de longo alcance? + +0:32:10.000,0:32:17.520 +A entrada para a rede conv basicamente visualizações multiescala de tipos de bandas da imagem ao redor do horizonte + +0:32:18.700,0:32:20.700 +não precisa entrar em detalhes + +0:32:21.940,0:32:25.710 +É uma rede neural muito pequena para o padrão de hoje, mas é o que poderíamos pagar. + +0:32:27.070,0:32:29.970 +Tenha um vídeo. Não tenho certeza se vai funcionar, mas vou tentar + +0:32:31.990,0:32:33.990 +Sim, funciona + +0:32:41.360,0:32:45.010 +Então, eu deveria falar um pouco sobre o personagem castor que ele representa aqui, então + +0:32:47.630,0:32:49.630 +Huh + +0:32:51.860,0:32:53.860 +Você não quer o áudio + +0:32:55.370,0:32:59.020 +Então Pierre Semanet e Raia Hadsell eram dois alunos + +0:32:59.600,0:33:02.560 +trabalhando comigo neste projeto, dois estudantes de doutorado + +0:33:03.170,0:33:08.200 +Pierre Sermanet está em Google Brain. Ele trabalha com robótica e Raia Hadsell é diretora de vendas de Robótica na DeepMind + +0:33:09.050,0:33:11.050 +Marco Scoffier é NVIDIA + +0:33:11.150,0:33:15.249 +Matt Grimes é um DeepMind, Jan Ben está no Mobile Eye, que agora é Intel + +0:33:15.920,0:33:17.920 +Ayse Erkan está em + +0:33:18.260,0:33:20.260 +Twitter e + +0:33:20.540,0:33:22.540 +Urs Muller ainda está trabalhando conosco, ele está + +0:33:22.910,0:33:29.139 +Na verdade, chefe de um grande grupo que trabalha em direção autônoma na Nvidia e está colaborando conosco + +0:33:30.800,0:33:32.800 +Na realidade + +0:33:33.020,0:33:38.020 +Nossos trabalhos posteriores neste projeto, então este é um robô + +0:33:39.290,0:33:44.440 +E pode dirigir sobre você sabe, uma espécie de velocidade de caminhada rápida + +0:33:46.310,0:33:48.999 +E é suposto dirigir-se em uma espécie de natureza + +0:33:50.720,0:33:55.930 +Então tem essa massa com quatro olhos, há dois pares estéreo para dois pares de câmeras estéreo e + +0:33:57.020,0:34:02.320 +Tem três computadores na barriga. Então é totalmente autônomo. Não fala com a rede nem nada + +0:34:03.200,0:34:05.200 +E aqueles aqueles três computadores + +0:34:07.580,0:34:10.120 +Eu estou à esquerda. Foi quando eu tinha um rabo de cavalo + +0:34:13.640,0:34:19.659 +Ok, então aqui o sistema é que a rede neural está aleijada, então não ligamos as redes neurais + +0:34:19.659,0:34:22.029 +Está usando apenas visão estéreo e agora está usando a rede neural + +0:34:22.130,0:34:26.529 +então está bem longe dessa barreira, mas ele a vê e vai diretamente para + +0:34:27.169,0:34:31.599 +O lado que ele quer ir para um objetivo, uma coordenada GPS. Isso está por trás disso. Mesmo aqui + +0:34:31.600,0:34:33.429 +Ele quer ir para uma coordenada GPS atrás dele + +0:34:33.429,0:34:37.689 +E vê logo que tem essa parede de gente que ele não consegue passar + +0:34:38.360,0:34:43.539 +O cara da direita aqui é Marcos, ele está segurando o transmissor, ele não está dirigindo o robô, mas está segurando o interruptor de matar + +0:34:48.849,0:34:50.849 +E assim + +0:34:51.039,0:34:54.689 +Você sabe, é assim que a rede convolucional se parece + +0:34:55.659,0:34:57.659 +muito pequeno para os padrões de hoje + +0:35:00.430,0:35:02.430 +E + +0:35:03.700,0:35:05.700 +E produz para cada + +0:35:06.400,0:35:08.400 +cada local cada patch na entrada + +0:35:08.829,0:35:13.859 +A segunda última camada é um vetor de 100 dimensões que entra em um classificador que classifica em cinco categorias + +0:35:14.650,0:35:16.650 +então, uma vez que o sistema classifica + +0:35:16.779,0:35:20.189 +Cada uma dessas cinco categorias na imagem você pode deformar a imagem + +0:35:20.349,0:35:25.979 +Em um mapa que está centrado no robô e você pode fazer o planejamento neste mapa para descobrir como evitar + +0:35:25.980,0:35:31.379 +Obstáculos e coisas assim. Então é isso que essa coisa faz. É um mapa particular chamado mapa hiperbólico, mas + +0:35:33.999,0:35:36.239 +Não é importante por enquanto + +0:35:38.380,0:35:40.380 +Agora isso + +0:35:40.509,0:35:42.509 +porque isso era você sabe + +0:35:42.970,0:35:49.199 +Em 2007, os computadores estavam lentamente, não havia GPUs, então poderíamos executar isso, poderíamos executar essa rede neural apenas em cerca de um quadro por + +0:35:49.200,0:35:50.859 +segundo + +0:35:50.859,0:35:54.268 +Como você pode ver aqui na parte inferior, ele atualiza cerca de um quadro por segundo + +0:35:54.269,0:35:54.640 +e + +0:35:54.640,0:35:59.609 +Então, se você tiver alguém andando na frente do robô, o robô não o verá por um segundo e você saberá? + +0:35:59.680,0:36:01.329 +Corre por cima dele + +0:36:01.329,0:36:07.079 +Então é por isso que temos um segundo sistema de visão aqui no topo. Este é estéreo. Não usa uma rede neural + +0:36:09.039,0:36:13.949 +Odometria acho que não nos importamos este é o controlador que também se aprende, mas não nos importamos e + +0:36:15.730,0:36:21.989 +Este é o sistema aqui novamente, sua visão é aleijada eles só podem ver até dois metros e meio + +0:36:21.989,0:36:23.989 +Então é muito curto + +0:36:24.099,0:36:26.099 +Mas meio que faz um trabalho decente + +0:36:26.529,0:36:28.529 +e + +0:36:28.930,0:36:34.109 +Isso é para testar esse tipo de sistema de visão de reação rápida ou aqui pierre-simon a está pulando na frente dele e + +0:36:34.420,0:36:40.950 +o robô para imediatamente para que agora esse seja o sistema completo com visão de longo alcance e + +0:36:41.950,0:36:43.950 +estudantes de graduação irritantes + +0:36:49.370,0:36:52.150 +Certo, então é meio que desistir + +0:37:03.970,0:37:06.149 +Ok, opa + +0:37:09.400,0:37:11.049 +OK, então + +0:37:11.049,0:37:12.690 +Isso se chama segmentação semântica + +0:37:12.690,0:37:18.329 +Mas a forma real de segmentação semântica é aquela em que você dá uma categoria de objeto para cada local + +0:37:18.729,0:37:21.599 +Então esse é o tipo de problema aqui que estamos falando sobre onde + +0:37:22.569,0:37:25.949 +cada pixel é um edifício ou céu ou + +0:37:26.769,0:37:28.769 +Rua ou um carro ou algo assim? + +0:37:29.799,0:37:37.409 +E por volta de 2010 alguns conjuntos de dados começaram a aparecer com alguns milhares de imagens onde você poderia treinar sistemas de visão para fazer isso + +0:37:39.940,0:37:42.059 +E então a técnica aqui é + +0:37:42.849,0:37:44.849 +essencialmente idêntico ao que eu + +0:37:45.309,0:37:47.309 +Descrito também é multi-escala + +0:37:48.130,0:37:52.920 +Então você basicamente tem uma imagem de entrada, você tem uma rede convolucional + +0:37:53.259,0:37:57.959 +que tem um conjunto de saídas que você conhece, uma para cada categoria + +0:37:58.539,0:38:01.258 +De objetos para os quais você tem rótulo, que neste caso é 33 + +0:38:02.680,0:38:05.879 +Quando você volta a projetar uma saída da rede convolucional na entrada + +0:38:06.219,0:38:11.249 +Corresponde a uma janela de entrada de 46 por 46 janelas. Então está usando um contexto de 46 + +0:38:12.309,0:38:16.889 +por 46 pixels para tomar a decisão sobre um único pixel, pelo menos esse é o + +0:38:17.589,0:38:19.589 +rede neural na parte de trás, na parte inferior + +0:38:19.900,0:38:24.569 +Mas tem 46, mas 46 não é suficiente se você quiser decidir o que é um pixel cinza + +0:38:24.569,0:38:27.359 +É a camisa da pessoa é a rua? É o + +0:38:28.119,0:38:31.679 +Nuvem ou tipo de pixel na montanha. Você tem que olhar para uma visão mais ampla + +0:38:32.650,0:38:34.650 +contexto para poder tomar essa decisão + +0:38:35.529,0:38:39.179 +Usamos novamente esse tipo de abordagem multiescala onde a mesma imagem é + +0:38:39.759,0:38:45.478 +Reduzido por um fator de 2 e um fator de 4 e você executa essas duas imagens extras para o mesmo convolucional + +0:38:45.479,0:38:47.789 +net mesmo peso mesmo kernel mesmo tudo + +0:38:48.940,0:38:54.089 +Exceto o último mapa de recursos, você os aprimora para que tenham o mesmo tamanho que o original + +0:38:54.089,0:38:58.859 +E agora você pega esses mapas de feições combinados e os envia para algumas camadas de um classificador + +0:38:59.410,0:39:01.410 +Então agora o classificador para tomar sua decisão + +0:39:01.749,0:39:07.738 +Possui quatro janelas de 46 por 46 em imagens que foram redimensionadas e, portanto, o efetivo + +0:39:08.289,0:39:12.718 +o tamanho do contexto agora é 184 por 184 janela porque + +0:39:13.269,0:39:15.269 +a escala central + +0:39:15.610,0:39:17.910 +A rede basicamente olha mais para todo esse + +0:39:19.870,0:39:21.870 +Imagem + +0:39:24.310,0:39:30.299 +Então você pode limpá-lo de várias maneiras, não vou entrar em detalhes, mas funciona muito bem + +0:39:33.970,0:39:36.330 +Então esse é o resultado + +0:39:37.870,0:39:40.140 +O cara que fez isso no meu laboratório é Clément Farabet + +0:39:40.170,0:39:46.319 +Ele é vice-presidente da Nvidia agora responsável por toda a infraestrutura de aprendizado de máquina e condução autônoma + +0:39:47.080,0:39:49.080 +Não surpreendentemente + +0:39:51.100,0:39:57.959 +E então esse sistema, você sabe, este é o Washington Square Park a propósito, então este é o campus da NYU + +0:39:59.440,0:40:02.429 +Não é perfeito longe disso. Você sabe + +0:40:03.220,0:40:06.300 +Identificou algumas áreas da rua como areia + +0:40:07.330,0:40:09.160 +ou deserto e + +0:40:09.160,0:40:12.479 +Não há praia. Estou ciente de em Washington Square Park + +0:40:13.750,0:40:15.750 +e + +0:40:16.480,0:40:17.320 +Mas você sabe + +0:40:17.320,0:40:22.469 +Na época, esse era o tipo de sistema desse tipo, o número de amostras de treinamento para isso era muito pequeno + +0:40:22.470,0:40:24.400 +então foi tipo + +0:40:24.400,0:40:27.299 +Foram cerca de 2.000 ou 3.000 imagens algo assim + +0:40:31.630,0:40:34.410 +Você corre, você tira uma imagem de resolução total + +0:40:36.220,0:40:42.689 +Você o executa para as primeiras n menos 2 camadas do seu ConvNet que fornece seus mapas futuros + +0:40:42.970,0:40:45.570 +Então você reduz a imagem por um fator de dois, executa-a novamente + +0:40:45.570,0:40:50.009 +Você obtém vários mapas de recursos que são menores e executados novamente reduzindo por um fator de quatro + +0:40:50.320,0:40:51.900 +Você obtém mapas de recursos menores + +0:40:51.900,0:40:52.420 +agora + +0:40:52.420,0:40:57.420 +Você pega o pequeno mapa de recursos e redimensiona-o, amostra-o para que fique do mesmo tamanho que o primeiro + +0:40:57.420,0:41:00.089 +para o segundo, você empilha todos esses mapas de recursos juntos + +0:41:00.880,0:41:07.199 +Ok, e que você alimente duas camadas para um classificador para cada patch + +0:41:07.980,0:41:12.240 +Sim, o artigo foi rejeitado no CVPR 2012, embora os resultados fossem + +0:41:13.090,0:41:14.710 +recorde e + +0:41:14.710,0:41:17.520 +Foi mais rápido que o melhor concorrente + +0:41:18.400,0:41:20.400 +método por um fator de 50 + +0:41:20.950,0:41:25.920 +Mesmo rodando em hardware padrão, mas também tivemos implementação em hardware especial que foi incrivelmente rápido + +0:41:26.980,0:41:28.130 +e + +0:41:28.130,0:41:34.600 +as pessoas não sabiam o que era a rede convolucional na época e, portanto, os revisores basicamente não conseguiam entender isso + +0:41:35.660,0:41:37.359 +O método que eles nunca ouviram falar poderia funcionar + +0:41:37.359,0:41:40.899 +Tão bem. Há muito mais a dizer sobre redes convolucionais + +0:41:40.900,0:41:44.770 +Mas eu encorajo você a fazer um curso de visão computacional para ouvir sobre isso + +0:41:45.950,0:41:49.540 +Sim, tudo bem este conjunto de dados este conjunto de dados específico que usamos + +0:41:51.590,0:41:57.969 +É uma coleção de imagens de rua que foi coletada principalmente por Antonio Torralba no MIT e + +0:42:02.690,0:42:04.130 +Ele tem um + +0:42:04.130,0:42:08.530 +uma espécie de ferramenta para rotular para que você pudesse saber, você poderia meio que + +0:42:09.140,0:42:12.100 +desenhe o contorno sobre o objeto e, em seguida, rotule o objeto e + +0:42:12.650,0:42:18.129 +Então se fosse meio, você sabe preencher o objeto que a maioria das segmentações foram feitas pela mãe dele + +0:42:20.030,0:42:22.030 +Quem está na Espanha + +0:42:22.310,0:42:24.310 +ela teve muito tempo para + +0:42:25.220,0:42:27.220 +Gaste fazendo isso + +0:42:27.380,0:42:29.300 +Huh? + +0:42:29.300,0:42:34.869 +Sua mãe sim rotulou essas coisas. Sim. Isso foi no final dos anos 2000 + +0:42:37.190,0:42:41.530 +Ok, agora vamos falar sobre um monte de arquiteturas diferentes, certo então + +0:42:43.400,0:42:45.520 +Você sabe como eu mencionei antes + +0:42:45.950,0:42:51.159 +a ideia de aprendizado profundo é que você tenha esse catálogo de módulos que você pode montar em diferentes gráficos e + +0:42:52.040,0:42:54.879 +e juntos para fazer diferentes funções e + +0:42:56.210,0:42:58.210 +e muito do + +0:42:58.430,0:43:03.280 +Expertise em deep learning é projetar essas arquiteturas para fazer algo em particular + +0:43:03.619,0:43:06.909 +É um pouco como, você sabe, nos primeiros dias da ciência da computação + +0:43:08.180,0:43:11.740 +Criar um algoritmo para escrever um programa foi uma espécie de novo conceito + +0:43:12.830,0:43:14.830 +você sabe reduzir um + +0:43:15.560,0:43:19.209 +Problema para um tipo de conjunto de instruções que poderia ser executado em um computador + +0:43:19.210,0:43:21.580 +Foi meio que algo novo e aqui está o mesmo problema + +0:43:21.830,0:43:26.109 +você tem que imaginar como reduzir uma função complexa em uma espécie de + +0:43:27.500,0:43:29.560 +gráfico possivelmente gráfico dinâmico de + +0:43:29.720,0:43:35.830 +Módulos funcionais dos quais você não precisa saber completamente a função, mas que você está indo para cuja função será finalizada aprendendo + +0:43:36.109,0:43:38.199 +Mas a arquitetura é super importante, claro + +0:43:38.920,0:43:43.359 +Como vimos com as redes convolucionais. a primeira categoria importante é a rede recorrente. assim + +0:43:44.180,0:43:47.379 +Nós vimos quando falamos sobre a retropropagação + +0:43:48.140,0:43:50.140 +Há um grande + +0:43:50.510,0:43:58.029 +A condição da condição era que o gráfico da interligação do módulo não pudesse ter laços. OK. Tinha que ser um + +0:43:59.299,0:44:04.059 +gráfico para o qual há pelo menos uma ordem parcial do módulo para que você possa calcular o + +0:44:04.819,0:44:09.489 +Os módulos de tal forma que quando você calcula a saída de um módulo todas as suas entradas estão disponíveis + +0:44:11.240,0:44:13.299 +Mas rede recorrente é aquela em que você tem loops + +0:44:14.480,0:44:15.490 +Como você lida com isso? + +0:44:15.490,0:44:18.459 +Então aqui está um exemplo de uma arquitetura de rede recorrente + +0:44:18.920,0:44:25.210 +Onde você tem uma entrada que varia ao longo do tempo X(t) que passa pela primeira rede neural. Vamos chamá-lo de codificador + +0:44:25.789,0:44:29.349 +Isso produz uma representação da entrada + +0:44:29.349,0:44:32.679 +Vamos chamá-lo de H(t) e ele entra em uma camada recorrente + +0:44:32.680,0:44:38.409 +Esta camada recorrente é uma função G que depende de parâmetros treináveis ​​W estes parâmetros treináveis ​​também para o encoder + +0:44:38.410,0:44:40.410 +mas eu não mencionei isso e + +0:44:41.150,0:44:42.680 +aquele + +0:44:42.680,0:44:46.480 +A camada recorrente leva em conta H(t), que é a representação da entrada + +0:44:46.480,0:44:49.539 +mas também leva em conta Z(t-1), que é a + +0:44:50.150,0:44:55.509 +Tipo de um estado oculto, que é sua saída em uma etapa de tempo anterior sua própria saída em uma etapa de tempo anterior + +0:44:56.299,0:44:59.709 +Ok, esta função G pode ser uma rede neural muito complicada dentro + +0:45:00.950,0:45:06.519 +rede convolucional o que quer que seja tão complicado quanto você quiser. Mas o importante é que uma de suas entradas é + +0:45:08.869,0:45:10.869 +Sua saída em uma etapa de tempo anterior + +0:45:11.630,0:45:13.160 +OK + +0:45:13.160,0:45:15.049 +Z(t-1) + +0:45:15.049,0:45:21.788 +Então é por isso que esse atraso indica aqui. A entrada de G no tempo t é na verdade Z(t-1) + +0:45:21.789,0:45:24.459 +Qual é a saída sua saída em uma etapa de tempo anterior + +0:45:27.230,0:45:32.349 +Ok, então a saída desse módulo recorrente vai para um decodificador que basicamente produz uma saída + +0:45:32.450,0:45:35.710 +Ok, então transforma uma representação oculta Z em uma saída + +0:45:39.859,0:45:41.979 +Então, como você lida com isso, você desenrola o loop + +0:45:44.230,0:45:47.439 +Este é basicamente o mesmo diagrama, mas eu o desenrolei a tempo + +0:45:49.160,0:45:56.170 +Ok, então no momento 0 eu tenho X(0) que passa pelo codificador produz H de 0 e então eu aplico + +0:45:56.170,0:46:00.129 +A função G eu começo com um Z arbitrário Z, talvez 0 ou algo assim + +0:46:01.160,0:46:05.980 +E eu aplico a função e recebo Z(0) e isso entra no decodificador produz uma saída + +0:46:06.650,0:46:08.270 +OK + +0:46:08.270,0:46:09.740 +e então + +0:46:09.740,0:46:16.479 +Agora que tem Z(0) no passo de tempo 1. Posso usar o Z(0) como a saída anterior para o passo de tempo. OK + +0:46:17.570,0:46:22.570 +Agora a saída é X(1) e tempo 1. Eu corro pelo codificador eu corro pela camada recorrente + +0:46:22.570,0:46:24.570 +Que agora não é mais recorrente + +0:46:24.890,0:46:28.510 +E percorrer o decodificador e, em seguida, o próximo passo de tempo, etc + +0:46:29.810,0:46:34.269 +Ok, esta rede que está envolvida no tempo não tem mais loops + +0:46:37.130,0:46:39.040 +O que significa que posso executar retropropagação através dele + +0:46:39.040,0:46:44.259 +Então, se eu tenho uma função objetivo que diz que a última saída deve ser aquela em particular + +0:46:45.020,0:46:48.609 +Ou talvez a trajetória deva ser uma das saídas em particular. eu + +0:46:49.730,0:46:51.760 +Pode apenas voltar a propagar o gradiente através dessa coisa + +0:46:52.940,0:46:55.510 +É uma rede regular com um + +0:46:56.900,0:46:59.980 +Característica particular, que é que cada bloco + +0:47:01.609,0:47:03.609 +Compartilha os mesmos pesos + +0:47:04.040,0:47:07.509 +Ok, então as três instâncias do codificador + +0:47:08.150,0:47:11.379 +Eles são o mesmo codificador em três etapas de tempo diferentes + +0:47:11.380,0:47:16.869 +Então eles têm os mesmos pesos as mesmas funções G tem os mesmos pesos, os três decodificadores têm os mesmos pesos. sim + +0:47:20.990,0:47:23.260 +Pode ser variável, você sabe, eu tenho que decidir com antecedência + +0:47:25.160,0:47:27.399 +Mas isso depende do comprimento da sua sequência de entrada + +0:47:28.579,0:47:30.109 +basicamente + +0:47:30.109,0:47:33.159 +Certo e você sabe, é você pode executá-lo pelo tempo que quiser + +0:47:33.890,0:47:38.290 +Você sabe, são os mesmos pesos para que você possa saber, repita a operação + +0:47:40.130,0:47:46.390 +Ok, essa técnica de desenrolar e depois voltar a propagar através do tempo basicamente é chamada surpreendentemente + +0:47:47.060,0:47:49.060 +Suporte traseiro BPTT ao longo do tempo + +0:47:50.000,0:47:52.000 +É bem óbvio + +0:47:53.470,0:47:55.470 +Isso é tudo o que há para isso + +0:47:56.710,0:48:01.439 +Infelizmente, eles não funcionam muito bem, pelo menos não em sua forma ingênua + +0:48:03.910,0:48:06.000 +Então, na forma ingênua + +0:48:07.360,0:48:11.519 +Assim, uma forma simples de rede recorrente é aquela em que o codificador é linear + +0:48:11.770,0:48:16.560 +A função G é linear com alta provavelmente tangente ou sigmóide ou talvez ReLU + +0:48:17.410,0:48:22.680 +E o decodificador também é linear algo assim talvez com um ReLU ou algo assim, certo então pode ser bem simples + +0:48:23.530,0:48:24.820 +e + +0:48:24.820,0:48:27.539 +Você tem uma série de problemas com isso e um problema é? + +0:48:29.290,0:48:32.969 +O chamado problema do gradiente de fuga ou problema do gradiente explosivo + +0:48:34.060,0:48:38.640 +E isso vem do fato de que se você tem uma sequência longa, digamos que eu não saiba 50 passos de tempo + +0:48:40.060,0:48:44.400 +Toda vez que você volta a propagar gradientes + +0:48:45.700,0:48:52.710 +Os gradientes que são multiplicados pela matriz de pesos da função G. Ok a cada passo de tempo + +0:48:54.010,0:48:58.560 +os gradientes são multiplicados pela matriz de pesos agora imagine que a matriz de pesos tem + +0:48:59.110,0:49:00.820 +pequenos valores nele + +0:49:00.820,0:49:07.049 +O que significa que toda vez que você pega seu gradiente, você o multiplica pela transposição desta matriz para obter o gradiente anterior + +0:49:07.050,0:49:08.290 +passo de tempo + +0:49:08.290,0:49:10.529 +Você obtém um vetor menor, obtém um vetor menor + +0:49:11.200,0:49:14.520 +E você continua rolando o vetor fica cada vez mais curto exponencialmente + +0:49:14.980,0:49:18.449 +Isso é chamado de problema do gradiente de fuga quando você chega ao 50º + +0:49:19.210,0:49:23.100 +Passos de tempo que é realmente o primeiro passo de tempo. Você não recebe nenhum gradiente + +0:49:28.660,0:49:32.970 +Por outro lado, se a matriz de peso for muito grande e a não linearidade e seu + +0:49:33.760,0:49:36.120 +A camada recorrente não está saturando + +0:49:36.670,0:49:41.130 +seus gradientes podem explodir se a matriz de peso for grande toda vez que você multiplicar o + +0:49:41.650,0:49:43.650 +gradiente pela transposição da matriz + +0:49:43.660,0:49:46.920 +o vetor fica maior e explode, o que significa + +0:49:47.290,0:49:51.810 +seus pesos vão divergir quando você fizer uma etapa de gradiente ou você terá que usar uma pequena taxa de aprendizado para + +0:49:51.810,0:49:53.810 +trabalhar + +0:49:54.490,0:49:56.290 +assim + +0:49:56.290,0:49:58.529 +Você tem que usar muitos truques para fazer essas coisas funcionarem + +0:49:59.860,0:50:04.620 +Aqui está outro problema. A razão pela qual você gostaria de usar uma rede recorrente. Por que você iria querer usar uma rede recorrente? + +0:50:05.690,0:50:12.639 +A suposta vantagem da rede recorrente é que eles podem se lembrar de coisas distantes no passado + +0:50:13.850,0:50:15.850 +OK + +0:50:16.970,0:50:24.639 +Se por exemplo você imaginar que os X's são nossos caracteres que você digita um a um + +0:50:25.940,0:50:31.300 +Os personagens vêm de não conheço um programa em C ou algo do tipo, certo? + +0:50:34.070,0:50:35.300 +E + +0:50:35.300,0:50:37.870 +O que seu sistema deve dizer no final, sabe? + +0:50:37.870,0:50:42.699 +ele lê algumas centenas de caracteres correspondentes ao código-fonte de uma função e no final é + +0:50:43.730,0:50:49.090 +você deseja treinar seu sistema para que ele produza um se for um programa sintaticamente correto e + +0:50:49.910,0:50:51.910 +Menos um se não estiver tudo bem + +0:50:52.430,0:50:54.320 +problema hipotético + +0:50:54.320,0:50:57.489 +Redes recorrentes não farão isso. Ok, pelo menos não com nossos truques + +0:50:59.180,0:51:02.500 +Agora há uma coisa aqui que é a questão que é que + +0:51:03.860,0:51:07.599 +Entre outras coisas, este programa deve ter chaves e parênteses balanceados + +0:51:09.110,0:51:10.280 +assim + +0:51:10.280,0:51:13.540 +Tem que ter uma maneira de lembrar quantos parênteses abertos + +0:51:13.540,0:51:20.350 +existem para que ele possa verificar se você está fechando todos eles ou quantos colchetes abertos existem para que todos sejam + +0:51:21.620,0:51:24.939 +Feche bem para que tenha que armazenar eventualmente, você sabe + +0:51:27.380,0:51:29.410 +Essencialmente dentro de seu estado oculto Z + +0:51:29.410,0:51:32.139 +ele tem que armazenar como quantos chaves e e + +0:51:32.630,0:51:37.240 +Os parênteses estavam abertos se quiser poder dizer no final que todos eles foram fechados + +0:51:38.620,0:51:41.040 +Então tem que ter algum tipo de contador dentro certo + +0:51:43.180,0:51:45.080 +sim + +0:51:45.080,0:51:47.840 +Vai ser um tópico amanhã + +0:51:51.050,0:51:56.469 +Agora, se o programa for muito longo, isso significa que você sabe que Z precisa preservar as informações por um longo tempo e + +0:51:57.230,0:52:02.679 +Rede recorrente, você sabe, dá a esperança de que talvez um sistema como esse possa fazer isso, mas por causa de um problema de gradiente de fuga + +0:52:02.810,0:52:05.259 +Eles realmente não pelo menos não são simples + +0:52:07.280,0:52:09.280 +Redes recorrentes + +0:52:09.440,0:52:11.440 +Do tipo. acabei de descrever + +0:52:12.080,0:52:14.080 +Então você tem que usar um monte de truques + +0:52:14.200,0:52:18.460 +Esses são truques que você conhece do laboratório de Yoshua Bengio, mas tem um monte deles que foram publicados por várias pessoas + +0:52:19.700,0:52:22.090 +Como Thomas Mikolov e várias outras pessoas + +0:52:24.050,0:52:27.789 +Então, para evitar gradientes explosivos, você pode recortar os gradientes que você conhece, faça você saber + +0:52:27.790,0:52:30.279 +Se os gradientes ficarem muito grandes, você apenas os esmaga + +0:52:30.950,0:52:32.950 +Basta normalizá-los + +0:52:35.180,0:52:41.800 +Momento de integração fraco Não vou mencionar isso. uma boa inicialização, então você deseja inicializar as matrizes de peso para que + +0:52:42.380,0:52:44.380 +Eles preservam a norma mais ou menos + +0:52:44.660,0:52:49.180 +este é realmente um monte de artigos sobre isso em redes neurais ortogonais e inversíveis + +0:52:49.700,0:52:51.700 +Redes recorrentes + +0:52:54.770,0:52:56.770 +Mas o grande truque é + +0:52:57.470,0:53:04.630 +LSTM e GRUs. OK. Então o que é isso antes de falar sobre isso vou falar sobre módulos multiplicativos + +0:53:06.410,0:53:08.470 +Então, o que são módulos multiplicativos + +0:53:09.500,0:53:11.000 +Eles são basicamente + +0:53:11.000,0:53:14.709 +Módulos nos quais você pode multiplicar coisas entre si + +0:53:14.710,0:53:20.590 +Então, em vez de apenas calcular uma soma ponderada de entradas, você calcula os produtos de entradas e, em seguida, a soma ponderada disso + +0:53:20.600,0:53:23.110 +Ok, então você tem um exemplo disso no canto superior esquerdo + +0:53:23.720,0:53:25.040 +no topo + +0:53:25.040,0:53:29.080 +então a saída de um sistema aqui é apenas uma soma ponderada de + +0:53:30.080,0:53:32.080 +pesos e entradas + +0:53:32.240,0:53:37.810 +Ok clássico, mas os pesos na verdade são somas ponderadas de pesos e entradas + +0:53:38.780,0:53:43.149 +ok, então Wij aqui, que é o ij'th termo na matriz de peso de + +0:53:43.820,0:53:46.479 +O módulo que estamos considerando é na verdade ele mesmo + +0:53:47.270,0:53:49.270 +uma soma ponderada de + +0:53:50.060,0:53:53.439 +três tensores de terceira ordem Uijk + +0:53:54.410,0:53:56.560 +ponderado por variáveis ​​Zk. + +0:53:58.220,0:54:02.080 +Ok, então basicamente o que você obtém é que Wij é uma soma ponderada de + +0:54:04.160,0:54:06.160 +Matrizes + +0:54:06.800,0:54:08.800 +Reino Unido + +0:54:09.020,0:54:13.419 +Ponderado por um coeficiente Zk e o Zk pode mudar existem variáveis ​​de entrada da mesma forma + +0:54:13.460,0:54:17.230 +Então, na verdade, é como ter uma rede neural + +0:54:18.260,0:54:22.600 +Com matriz de peso W cuja matriz de peso é calculada por outra rede neural + +0:54:24.710,0:54:30.740 +Existe uma forma geral disso onde você não apenas multiplica matrizes, mas você tem uma rede neural que é uma função complexa + +0:54:31.650,0:54:33.650 +transforma X em S + +0:54:34.859,0:54:40.819 +Alguma função genérica. Ok, dê a você o ConvNet e os pesos dessas redes neurais + +0:54:41.910,0:54:44.839 +não são variáveis ​​que você aprende diretamente, mas são a saída de + +0:54:44.970,0:54:48.800 +Outro neurônio que leva em consideração talvez outra entrada ou talvez a mesma entrada + +0:54:49.830,0:54:55.069 +Algumas pessoas chamam essas arquiteturas de hiper-redes. OK. Existem redes cujos pesos são calculados por outra rede + +0:54:56.160,0:54:59.270 +Mas aqui está apenas uma forma simples, que é uma forma bilinear + +0:54:59.970,0:55:01.740 +ou quadrático + +0:55:01.740,0:55:03.180 +Formato + +0:55:03.180,0:55:05.810 +Ok, então no geral, quando você escreve tudo + +0:55:06.570,0:55:13.339 +SI é igual a soma sobre j E k de Uijk Zk Xj. Esta é uma soma dupla + +0:55:15.750,0:55:18.169 +As pessoas costumavam chamar isso de unidades Sigma Pi, sim + +0:55:22.890,0:55:27.290 +Chegaremos a isso em apenas um segundo basicamente + +0:55:31.500,0:55:33.500 +Se você quer uma rede neural que possa + +0:55:34.740,0:55:36.740 +realizar uma transformação de + +0:55:37.440,0:55:41.929 +Um vetor em outro e essa transformação deve ser programável + +0:55:42.990,0:55:50.089 +Certo, você pode fazer com que essa transformação seja calculada por uma rede neural, mas o peso dessa rede neural seria a saída + +0:55:50.089,0:55:51.390 +do + +0:55:51.390,0:55:54.200 +Outra rede neural que descobre qual é a transformação + +0:55:55.349,0:56:01.399 +Essa é a forma mais geral, mais especificamente, é muito útil se você quiser rotear + +0:56:03.359,0:56:08.389 +Sinais através de uma rede neural de diferentes maneiras em uma maneira dependente de dados para + +0:56:10.980,0:56:16.669 +Você de fato é exatamente isso que está mencionado abaixo, então o módulo de atenção é um caso especial disso + +0:56:17.460,0:56:20.510 +Não é uma camada quadrática. É um tipo diferente, mas é um + +0:56:21.510,0:56:23.510 +determinado tipo de + +0:56:25.140,0:56:26.849 +Arquitetura que + +0:56:26.849,0:56:28.849 +basicamente calcula um + +0:56:29.339,0:56:32.029 +combinação linear convexa de um monte de vetores, então + +0:56:32.790,0:56:34.849 +x₁ e x₂ aqui são vetores + +0:56:37.770,0:56:42.499 +w₁ e w₂ são escalares, basicamente, ok e + +0:56:45.540,0:56:47.870 +O que o sistema calcula aqui é uma soma ponderada de + +0:56:49.590,0:56:55.069 +x₁ e x₂ ponderados por w₁ w₂ e novamente w₁ w₂ são escalares neste caso + +0:56:56.910,0:56:58.910 +Aqui a soma na saída + +0:56:59.730,0:57:01.020 +assim + +0:57:01.020,0:57:07.999 +Imagine que esses dois pesos. w₁ w₂ estão entre 0 e 1 e somam 1 isso é o que é chamado de combinação linear convexa + +0:57:10.260,0:57:13.760 +Então, alterando w₁ w₂ tão essencialmente + +0:57:15.480,0:57:18.139 +Se essa soma for 1 há a saída de um softmax + +0:57:18.810,0:57:23.629 +O que significa que w₂ é igual a 1 - w₁ certo? Esse é o tipo de consequência direta + +0:57:27.450,0:57:29.450 +Então basicamente mudando + +0:57:29.790,0:57:34.340 +o tamanho de w₁ w₂ você meio que muda a saída para + +0:57:34.530,0:57:39.860 +Sendo x₁ ou x₂ ou alguma combinação linear dos dois alguma interpolação entre os dois + +0:57:41.610,0:57:43.050 +OK + +0:57:43.050,0:57:47.179 +Você pode ter mais do que apenas x₁ e x₂, você pode ter um monte de vetores x + +0:57:48.360,0:57:50.360 +e essa + +0:57:50.730,0:57:54.800 +sistema irá basicamente escolher uma combinação linear apropriada ou foco + +0:57:55.140,0:58:02.210 +É chamado de mecanismo de atenção porque permite que uma rede neural basicamente concentre sua atenção em uma entrada específica e ignorando as outras. + +0:58:02.880,0:58:05.240 +A escolha desta é feita por outra variável Z + +0:58:05.790,0:58:09.679 +O que em si poderia ser a saída para alguma outra rede neural que analisa Xs, por exemplo + +0:58:10.740,0:58:12.270 +tudo bem e + +0:58:12.270,0:58:18.409 +Isso se tornou um tipo de função extremamente importante, é usado em muitas situações diferentes agora + +0:58:19.440,0:58:22.700 +Em particular, é usado em LSTM e GRU, mas também é usado em + +0:58:26.730,0:58:30.020 +Praticamente todos os sistemas de processamento de linguagem natural hoje em dia que usam + +0:58:31.830,0:58:37.939 +Ou arquiteturas de transformadores ou todos os tipos de atenção que todos usam esse tipo de truque + +0:58:43.280,0:58:46.570 +Ok, então você tem um vetor Z passando para um softmax + +0:58:46.570,0:58:52.509 +Você obtém um monte de números entre 0 e 1 que somam a 1, use-os como coeficiente para calcular uma soma ponderada + +0:58:52.700,0:58:54.560 +de um monte de vetores X + +0:58:54.560,0:58:56.589 +xᵢ e você obtém a soma ponderada + +0:58:57.290,0:59:00.070 +Ponderados por esses coeficientes, esses coeficientes são dependentes de dados + +0:59:00.890,0:59:02.890 +Porque Z é dependente de dados + +0:59:05.390,0:59:07.390 +Tudo bem, então + +0:59:09.800,0:59:13.659 +Aqui está um exemplo de como você usa isso sempre que tiver este símbolo aqui + +0:59:15.530,0:59:17.859 +Este círculo com os pontos no meio, é um + +0:59:20.510,0:59:26.739 +Multiplicação componente por componente de dois vetores, algumas pessoas chamam esse produto de Hadamard + +0:59:29.660,0:59:34.629 +De qualquer forma, é a multiplicação passo a passo. Então isso é um + +0:59:36.200,0:59:41.020 +um tipo de um tipo de módulo funcional + +0:59:43.220,0:59:47.409 +GRU, gated recorrente Nets, foi proposto por Kyunghyun Cho que é professor aqui + +0:59:50.420,0:59:51.880 +E ele tenta + +0:59:51.880,0:59:54.430 +É uma tentativa de corrigir o problema que ocorre naturalmente em + +0:59:54.560,0:59:58.479 +Nets recorrentes que mencionei o fato de você ter explodindo gradiente o fato de que o + +0:00:00.050,0:00:04.629 +as redes recorrentes realmente não se lembram de seus estados por muito tempo. Eles tendem a esquecer muito rapidamente + +0:00:05.150,0:00:07.540 +E então é basicamente uma célula de memória + +0:00:08.060,0:00:14.080 +Ok, e eu tenho que dizer que este é o tipo de segunda grande família do tipo + +0:00:16.820,0:00:20.919 +Rede recorrente com memória. O primeiro é o LSTM, mas vou falar dele logo depois + +0:00:21.650,0:00:23.650 +Só porque este é um pouco mais simples + +0:00:24.950,0:00:27.550 +As equações são escritas na parte inferior aqui, então + +0:00:28.280,0:00:30.280 +basicamente, existe um + +0:00:31.280,0:00:32.839 +uma + +0:00:32.839,0:00:34.839 +vetor Z + +0:00:35.720,0:00:37.550 +qual é + +0:00:37.550,0:00:41.919 +simplesmente a aplicação de uma função não linear a função sigmóide + +0:00:42.950,0:00:44.089 +para + +0:00:44.089,0:00:49.119 +duas camadas lineares e uma polarização e essas duas camadas lineares levam em consideração a entrada X(t) e + +0:00:49.400,0:00:54.389 +O estado anterior em que eles notaram H no caso deles, não Z como eu fiz + +0:00:55.930,0:01:01.889 +Ok, então você pega X você pega H você calcula matrizes + +0:01:02.950,0:01:04.140 +Você passa um resultado + +0:01:04.140,0:01:07.440 +você adiciona os resultados, passa-os por funções sigmoid e obtém um monte de + +0:01:07.539,0:01:11.939 +valores entre 0 e 1 porque o sigmóide está entre 0 e 1 fornece um coeficiente e + +0:01:14.140,0:01:16.140 +Você usa esses coeficientes + +0:01:16.660,0:01:20.879 +Você vê a fórmula na parte inferior o Z é usado basicamente para calcular uma combinação linear + +0:01:21.700,0:01:24.210 +de duas entradas se Z for igual a 1 + +0:01:25.420,0:01:28.379 +Você basicamente só olha para h(t-1). Se Z + +0:01:29.859,0:01:35.669 +É igual a 0 então 1 - Z é igual a 1 então você olha para isso + +0:01:36.400,0:01:38.109 +expressão aqui e + +0:01:38.109,0:01:43.528 +Essa expressão é, você conhece alguma matriz de peso multiplicada pela entrada passada por uma função tangente hiperbólica + +0:01:43.529,0:01:46.439 +Pode ser um ReLU, mas é uma tangente hiperbólica neste caso + +0:01:46.839,0:01:49.528 +E é combinado com outras coisas aqui que podemos ignorar por enquanto + +0:01:50.829,0:01:58.439 +OK. Então, basicamente, o que o valor Z faz é dizer ao sistema que apenas copie se Z for igual a 1, ele apenas copia seu + +0:01:58.440,0:02:00.440 +estado anterior e ignora a entrada + +0:02:00.789,0:02:04.978 +Ok, então ele age essencialmente como uma memória. Ele apenas copia seu estado anterior em sua saída + +0:02:06.430,0:02:08.430 +e se Z + +0:02:09.549,0:02:17.189 +É igual a 0, então o estado atual é esquecido essencialmente e é basicamente você leria a entrada + +0:02:19.450,0:02:24.629 +Ok multiplicado por alguma matriz para alterar o estado do sistema + +0:02:28.960,0:02:35.460 +Sim, você faz esse componente por componente essencialmente, ok vetor 1 sim exatamente + +0:02:47.500,0:02:53.459 +Bem, é como o número de multiplicações independentes, certo, qual é a derivada de + +0:02:54.880,0:02:59.220 +alguma função objetivo em relação à entrada de um produto. É igual ao + +0:03:01.240,0:03:07.829 +Derivada dessa função objetivo em relação à soma, ao produto multiplicado pelo outro termo. Isso é tão simples quanto isso + +0:03:18.039,0:03:20.039 +Então é porque por padrão + +0:03:20.529,0:03:22.529 +essencialmente, a menos que Z seja + +0:03:23.619,0:03:25.509 +seu Z é + +0:03:25.509,0:03:30.689 +Mais menos por padrão igual a um e assim por padrão o sistema apenas copia seu estado anterior + +0:03:33.039,0:03:35.999 +E se é só você sabe um pouco menos de um + +0:03:37.210,0:03:42.539 +Ele coloca um pouco da entrada no estado, mas não altera significativamente o estado e o que isso significa. É isso + +0:03:43.630,0:03:44.799 +preserva + +0:03:44.799,0:03:46.919 +Norma, e preserva a informação, certo? + +0:03:48.940,0:03:53.099 +Desde basicamente célula de memória que você pode mudar continuamente + +0:04:00.480,0:04:04.159 +Bem, porque você precisa de algo entre zero e um, é um coeficiente, certo + +0:04:04.160,0:04:07.789 +E por isso precisa estar entre zero e um é o que fazemos sigmoids + +0:04:11.850,0:04:13.080 +eu + +0:04:13.080,0:04:16.850 +significa que você precisa de um que seja monotônico que vá entre 0 e 1 e + +0:04:17.970,0:04:20.059 +é monotônico e diferenciável, quero dizer + +0:04:20.730,0:04:22.849 +Há muitas funções sigmóides, mas você sabe + +0:04:24.000,0:04:26.000 +Por que não? + +0:04:26.100,0:04:29.779 +Sim, quero dizer, há algum argumento para usar outros, mas você sabe que não faz um grande + +0:04:30.540,0:04:32.540 +quantidade de diferença + +0:04:32.700,0:04:37.009 +Ok, na forma completa de gru. há também um portão de reset. Então a porta de reset é + +0:04:37.650,0:04:44.989 +Esse cara está aqui? Então R é outro vetor que é calculado também como uma combinação linear de entradas e estado anterior e + +0:04:45.660,0:04:51.319 +Serve para multiplicar o estado anterior. Então, se R é 0, então o estado anterior é + +0:04:52.020,0:04:54.410 +se R é 0 e Z é 1 + +0:04:55.950,0:05:00.499 +O sistema é basicamente completamente redefinido para 0 porque isso é 0 + +0:05:01.350,0:05:03.330 +Então ele só olha para a entrada + +0:05:03.330,0:05:09.950 +Mas isso é basicamente uma versão simplificada de algo que surgiu no início de 1997 chamado + +0:05:10.260,0:05:12.260 +Memória de curto prazo longa LSTM + +0:05:13.050,0:05:14.820 +Que você sabe que tentou + +0:05:14.820,0:05:19.519 +Que foi uma tentativa de resolver o mesmo problema que você sabe que as redes recorrentes basicamente perdem memória por muito tempo + +0:05:19.520,0:05:21.520 +e então você os constrói como + +0:05:22.860,0:05:26.120 +Como células de memória por padrão e por padrão, elas preservarão as informações + +0:05:26.760,0:05:28.430 +É essencialmente a mesma ideia aqui + +0:05:28.430,0:05:33.979 +É um você sabe, os detalhes são um pouco diferentes aqui não tem pontos no meio da forma redonda aqui para o produto + +0:05:33.980,0:05:35.610 +Mas é a mesma coisa + +0:05:35.610,0:05:41.539 +E há um pouco mais de peças móveis. É basicamente parece mais uma venda real + +0:05:41.540,0:05:44.060 +Então é como um flip-flop que você pode saber preservar + +0:05:44.430,0:05:48.200 +Informações e há algum vazamento que você pode ter, você pode redefini-lo para 0 ou para 1 + +0:05:48.810,0:05:50.810 +É bastante complicado + +0:05:52.050,0:05:59.330 +Felizmente, as pessoas da NVIDIA Facebook Google e vários outros lugares têm implementações muito eficientes para que você não precise + +0:05:59.550,0:06:01.550 +descobrir como escrever o + +0:06:01.620,0:06:03.710 +Código CUDA para isso ou escreva o pop de volta + +0:06:05.430,0:06:07.430 +Funciona muito bem + +0:06:07.500,0:06:12.689 +é bem o que você usaria, mas é usado cada vez menos porque + +0:06:13.539,0:06:15.539 +as pessoas usam redes recorrentes + +0:06:16.150,0:06:18.210 +as pessoas costumavam usar redes recorrentes para processamento de linguagem natural + +0:06:19.329,0:06:21.220 +principalmente e + +0:06:21.220,0:06:25.949 +Coisas como reconhecimento de fala e reconhecimento de fala estão se movendo para o uso de redes convolucionais + +0:06:27.490,0:06:29.200 +Redes condicionais temporais + +0:06:29.200,0:06:34.109 +enquanto o processamento de linguagem natural está se movendo para usar o que é chamado de transformadores + +0:06:34.630,0:06:36.900 +Sobre o qual ouviremos muito amanhã, certo? + +0:06:37.630,0:06:38.950 +não? + +0:06:38.950,0:06:40.950 +quando + +0:06:41.109,0:06:43.109 +daqui a duas semanas, ok + +0:06:46.599,0:06:48.599 +Então, quais são os transformadores + +0:06:49.119,0:06:51.119 +Ok, eu não vou falar sobre transformadores agora + +0:06:51.759,0:06:56.219 +mas esses transformadores de chave são uma espécie de generalização, então + +0:06:57.009,0:06:58.619 +Uso geral de atenção se quiser + +0:06:58.619,0:07:02.038 +Então, as grandes redes neurais que usam a atenção que você conhece + +0:07:02.039,0:07:06.329 +Cada bloco de neurônio usa atenção e isso tende a funcionar muito bem, funciona + +0:07:06.329,0:07:09.538 +Tão bem que as pessoas estão basicamente largando todo o resto pela PNL + +0:07:10.869,0:07:12.869 +então o problema é + +0:07:13.269,0:07:15.299 +Sistemas como o LSTM não são muito bons nisso, então + +0:07:16.599,0:07:20.219 +Os transformadores são muito melhores. Os maiores transformadores têm bilhões de parâmetros + +0:07:21.430,0:07:26.879 +Como o maior é por 15 bilhões algo assim nessa ordem de magnitude o t5 ou o que quer que seja chamado + +0:07:27.910,0:07:29.910 +do Google então + +0:07:30.460,0:07:36.779 +Isso é uma enorme quantidade de memória e é por causa do tipo particular de arquitetura que é usado em transformadores + +0:07:36.779,0:07:40.319 +Eles podem realmente armazenar muito conhecimento, se você quiser + +0:07:41.289,0:07:43.559 +Então essas são as coisas que as pessoas usariam para + +0:07:44.440,0:07:47.069 +Do que você está falando, como sistemas de resposta a perguntas + +0:07:47.769,0:07:50.099 +Sistemas de tradução etc. Eles usarão transformadores + +0:07:52.869,0:07:54.869 +OK + +0:07:57.619,0:08:01.778 +Então, porque o LSTM meio que foi meio que você sabe, um dos primeiros + +0:08:02.719,0:08:04.958 +arquiteturas arquitetura recorrente que meio que funcionou + +0:08:05.929,0:08:11.408 +As pessoas tentaram usá-los para coisas que a princípio você acharia loucura, mas acabou funcionando + +0:08:12.109,0:08:16.689 +E um exemplo disso é a tradução. Chama-se tradução automática neural + +0:08:17.509,0:08:19.509 +Então havia um papel + +0:08:19.639,0:08:22.149 +por Ilya Sutskever no NIPS 2014 onde ele + +0:08:22.969,0:08:29.799 +Treinou este gigante LSTM multicamada. Então, o que é um LSTM multicamadas? É um LSTM onde você tem + +0:08:30.589,0:08:36.698 +então é a versão desdobrada, certo? Então, na parte inferior, você tem um LSTM que é desdobrado em três etapas de tempo + +0:08:36.699,0:08:41.618 +Mas terá que ser desdobrado no comprimento de uma frase que você deseja traduzir, digamos um + +0:08:42.259,0:08:43.969 +frase em francês + +0:08:43.969,0:08:45.529 +e + +0:08:45.529,0:08:48.038 +E então você pega o oculto + +0:08:48.289,0:08:53.709 +estado em cada passo de tempo deste LSTM e você alimenta isso como entrada para um segundo LSTM e + +0:08:53.929,0:08:55.150 +acho que na rede dele + +0:08:55.150,0:08:58.329 +ele realmente tinha quatro camadas disso, então você pode pensar nisso como um + +0:08:58.639,0:09:02.139 +LSTM empilhado que você sabe que cada um deles é recorrente no tempo + +0:09:02.139,0:09:05.589 +Mas eles são empilhados como as camadas de uma rede neural + +0:09:06.500,0:09:07.670 +assim + +0:09:07.670,0:09:14.769 +No último passo de tempo na última camada, você tem um vetor aqui, que deve representar todo o significado dessa frase + +0:09:16.309,0:09:18.879 +Ok, então pode ser um vetor bastante grande + +0:09:19.849,0:09:24.819 +e então você alimenta isso para outro LSTM multicamada, que + +0:09:27.319,0:09:31.028 +Você sabe que corre por uma espécie de número indeterminado de passos e + +0:09:32.119,0:09:37.209 +O papel deste LSTM é produzir palavras em um idioma de destino, se você fizer tradução, diga alemão + +0:09:38.869,0:09:40.839 +Ok, então esta é a hora, você sabe + +0:09:40.839,0:09:44.499 +Leva o estado que você executa nas duas primeiras camadas do LSTM + +0:09:44.630,0:09:48.849 +Produza uma palavra e, em seguida, pegue essa palavra e alimente-a como entrada para a próxima etapa de tempo + +0:09:49.940,0:09:52.359 +Para que você possa gerar texto sequencialmente, certo? + +0:09:52.909,0:09:58.899 +Percorra isso, produza outra palavra, leve essa palavra de volta à entrada e continue. Então isso é um + +0:10:00.619,0:10:02.619 +Deve fazer isso para tradução você fica com esse gigantesco + +0:10:03.320,0:10:07.480 +Rede neural você treina e esse é o sistema desse tipo + +0:10:07.480,0:10:12.010 +Aquele que Sutskever representou no NIPS 2014 foi o primeiro neural + +0:10:13.130,0:10:19.209 +Sistema de tradução que teve desempenho que poderia rivalizar com abordagens mais clássicas não baseadas em redes neurais + +0:10:21.350,0:10:23.950 +E as pessoas ficaram realmente surpresas que você pudesse obter tais resultados + +0:10:26.840,0:10:28.840 +Esse sucesso durou muito pouco + +0:10:31.280,0:10:33.280 +Sim, então o problema é + +0:10:34.340,0:10:37.449 +A palavra que você vai dizer em um determinado momento depende da palavra que você acabou de dizer + +0:10:38.180,0:10:41.320 +Certo, e se você pedir ao sistema para produzir apenas uma palavra + +0:10:42.800,0:10:45.729 +E então você não alimenta essa palavra de volta para a entrada + +0:10:45.730,0:10:49.120 +o sistema pode ser usado em outra palavra que seja inconsistente com o anterior que você produziu + +0:10:55.790,0:10:57.790 +Deveria, mas não + +0:10:58.760,0:11:05.590 +Quero dizer, não bem o suficiente para que funcione. Então, isso é um tipo de produção sequencial que é praticamente necessária + +0:11:07.790,0:11:09.790 +Em princípio, você está certo + +0:11:10.910,0:11:12.910 +Não é muito satisfatório + +0:11:13.610,0:11:19.089 +então há um problema com isso que é que todo o significado da frase tem que ser meio que espremido + +0:11:19.430,0:11:22.419 +Esse estado oculto que está entre o codificador do decodificador + +0:11:24.530,0:11:29.829 +Esse é um problema, o segundo problema é que, apesar do fato de que os LSTM são construídos para preservar informações + +0:11:31.040,0:11:36.010 +São basicamente células de memória. Na verdade, eles não preservam informações por mais de 20 palavras + +0:11:36.860,0:11:40.299 +Então, se sua frase tiver mais de 20 palavras quando você chegar ao final da frase + +0:11:40.520,0:11:43.270 +Seu seu estado oculto terá esquecido o início dele + +0:11:43.640,0:11:49.269 +então o que as pessoas usam para isso, a correção para isso é um enorme hack chamado BiLSTM e + +0:11:50.060,0:11:54.910 +É uma ideia completamente trivial que consiste em executar dois LSTMs em direções opostas + +0:11:56.210,0:11:59.020 +Ok, e então você recebe dois códigos, um que é + +0:11:59.720,0:12:04.419 +executando o LSTM do início ao fim da frase que é um vetor e, em seguida, o segundo vetor é de + +0:12:04.730,0:12:09.939 +Executando um LSTM na outra direção, você obtém um segundo vetor. Esse é o significado da sua frase + +0:12:10.280,0:12:16.809 +Você pode basicamente dobrar o comprimento de sua frase sem perder muita informação dessa maneira, mas não é uma solução muito satisfatória + +0:12:17.120,0:12:19.450 +Então, se você vir biLSTM, é isso que é + +0:12:22.830,0:12:29.179 +Então, como eu disse, o sucesso durou pouco porque, na verdade, antes do artigo ser publicado no NIPS + +0:12:30.390,0:12:32.390 +Havia um papel de + +0:12:34.920,0:12:37.969 +Dzmitry Bahdanau, Kyunghyun Cho e Yoshua Bengio + +0:12:38.670,0:12:42.319 +que foi publicado no arxiv em 14 de setembro que dizia + +0:12:43.560,0:12:47.209 +Podemos usar a atenção. Então, o mecanismo de atenção que mencionei anteriormente + +0:12:49.320,0:12:51.300 +Em vez de ter aqueles gigantescos + +0:12:51.300,0:12:54.890 +Redes e espremendo todo o significado de uma frase neste pequeno vetor + +0:12:55.800,0:12:58.190 +faria mais sentido para a tradução se + +0:12:58.710,0:13:03.169 +Cada vez dito, você sabe, queremos produzir uma palavra em francês correspondente a uma frase em inglês + +0:13:04.469,0:13:08.509 +Se olharmos para o local na frase em inglês que tinha essa palavra + +0:13:09.390,0:13:10.620 +OK + +0:13:10.620,0:13:12.090 +assim + +0:13:12.090,0:13:17.540 +Nosso decodificador vai produzir palavras em francês uma de cada vez e quando se trata de produzir uma palavra + +0:13:18.449,0:13:21.559 +que tem um equivalente na frase de entrada em inglês é + +0:13:21.960,0:13:29.750 +vai focar sua atenção nessa palavra e então a tradução do francês para o inglês dessa palavra seria simples ou o + +0:13:30.360,0:13:32.300 +Você sabe, pode não ser uma única palavra + +0:13:32.300,0:13:34.050 +poderia ser um grupo de palavras certo porque + +0:13:34.050,0:13:39.590 +Muitas vezes você tem que transformar um grupo de palavras em inglês em um grupo de palavras em francês para dizer o mesmo + +0:13:39.590,0:13:41.590 +coisa se for alemão você tem que + +0:13:42.150,0:13:43.949 +coloque o + +0:13:43.949,0:13:47.479 +Você conhece o verbo no final da frase, enquanto em inglês, pode estar no início + +0:13:48.060,0:13:51.109 +Então, basicamente, você usa esse mecanismo de atenção + +0:13:51.110,0:13:57.440 +então este módulo de atenção aqui é o que eu mostrei alguns slides antes que basicamente decide + +0:13:58.739,0:14:04.428 +Em qual dos passos de tempo qual da representação oculta para qual outra palavra na sentença de entrada ela irá focar? + +0:14:06.570,0:14:12.259 +Para produzir uma representação que produzirá a palavra atual em um determinado intervalo de tempo + +0:14:12.260,0:14:15.320 +Então aqui estamos na etapa de tempo número três, vamos produzir uma terceira palavra + +0:14:16.140,0:14:21.829 +E teremos que decidir qual palavra de entrada corresponde a isso e teremos esse mecanismo de atenção + +0:14:21.830,0:14:23.830 +então, essencialmente, vamos ter um + +0:14:25.140,0:14:28.759 +Pequeno pedaço de rede neural que vai olhar para as entradas deste lado + +0:14:31.809,0:14:35.879 +Vai ter uma saída que vai passar por um soft max que vai produzir um monte de + +0:14:35.979,0:14:42.269 +Coeficientes que somam 1 entre 0 e 1 e eles vão calcular uma combinação linear dos estados em diferentes etapas de tempo + +0:14:43.719,0:14:48.899 +Ok, definindo um desses coeficientes para 1 e os outros para 0, ele focará a atenção do sistema em + +0:14:48.900,0:14:50.900 +uma palavra específica + +0:14:50.949,0:14:56.938 +Então a mágica disso é que essa rede neural que decide que vai até o softmax e decide sobre esses coeficientes na verdade + +0:14:57.159,0:14:59.159 +Pode ser treinado com suporte traseiro é apenas mais um + +0:14:59.590,0:15:03.420 +Conjunto de pesos em uma rede neural e você não precisa construí-lo manualmente. Isso só dá conta + +0:15:06.550,0:15:10.979 +Isso revolucionou completamente o campo da tradução automática neural no sentido de que + +0:15:11.889,0:15:13.889 +dentro de um + +0:15:14.050,0:15:20.309 +A equipe de poucos meses de Stanford venceu uma grande competição com isso batendo todos os outros métodos + +0:15:22.119,0:15:28.199 +E então, em três meses, todas as grandes empresas que trabalham com tradução basicamente implantaram sistemas baseados nesse + +0:15:29.289,0:15:31.469 +Então isso apenas mudou tudo + +0:15:33.189,0:15:40.349 +E então as pessoas começaram a prestar atenção na atenção, ok, preste mais atenção na atenção no sentido de que + +0:15:41.170,0:15:44.879 +E então havia um artigo de um monte de gente no Google + +0:15:45.729,0:15:52.529 +O que o título era atenção é tudo que você precisa e foi basicamente um artigo que resolveu um monte de tarefas de processamento de linguagem natural + +0:15:53.050,0:15:59.729 +usando uma rede neural onde cada camada, cada grupo de neurônios basicamente estava implementando a atenção e é isso que um + +0:16:00.459,0:16:03.149 +Ou algo chamado auto-atenção. Isso é o que é um transformador + +0:16:08.829,0:16:15.449 +Sim, você pode ter um número variável de saídas de entradas nas quais você foca sua atenção + +0:16:18.340,0:16:20.849 +Ok, vou falar agora sobre redes de memória + +0:16:35.450,0:16:40.309 +Então isso vem do trabalho no Facebook que foi iniciado por Antoine Bordes + +0:16:41.970,0:16:43.970 +Acho que em 2014 e + +0:16:45.480,0:16:47.480 +De + +0:16:49.650,0:16:51.799 +Sainbayar Sukhbaatar, eu + +0:16:56.760,0:16:58.760 +Pense em 2015 ou 16 + +0:16:59.040,0:17:01.040 +Redes de memória de ponta a ponta chamadas + +0:17:01.520,0:17:06.890 +Sainbayar Sukhbaatar era estudante de doutorado aqui e era estagiário no Facebook quando trabalhou nisso + +0:17:07.650,0:17:10.220 +junto com um monte de outras pessoas Facebook e + +0:17:10.860,0:17:12.090 +a ideia de memória + +0:17:12.090,0:17:17.270 +Rede é que você gostaria de ter uma memória de curto prazo você gostaria que sua rede neural tivesse uma memória de curto prazo ou memória de trabalho + +0:17:18.300,0:17:23.930 +Ok, você gostaria que você sabe, você conta tudo bem, se eu te contar uma história eu te conto + +0:17:25.410,0:17:27.410 +João vai para a cozinha + +0:17:28.170,0:17:30.170 +João pega o leite + +0:17:34.440,0:17:36.440 +Jane vai para a cozinha + +0:17:37.290,0:17:40.910 +E então John vai para o quarto e joga o leite lá + +0:17:41.430,0:17:44.899 +E então volta para a cozinha e te pergunta. Onde está o leite? OK + +0:17:44.900,0:17:47.720 +então toda vez que eu te disse uma frase você meio que + +0:17:48.330,0:17:50.330 +atualizado em sua mente um + +0:17:50.340,0:17:52.340 +Tipo de estado atual do mundo, se você quiser + +0:17:52.920,0:17:56.870 +e assim, ao contar a história, você agora tem uma representação do estado para o mundo e se eu lhe perguntar uma + +0:17:56.870,0:17:59.180 +Pergunta sobre o estado do mundo, você pode respondê-la. OK + +0:18:00.270,0:18:02.270 +Você armazena isso em uma memória de curto prazo + +0:18:03.720,0:18:06.769 +Você não armazenou, ok, então tem isso + +0:18:06.770,0:18:10.399 +Há várias partes diferentes em seu cérebro, mas são duas partes importantes, uma é o córtex + +0:18:10.470,0:18:13.279 +O córtex é onde você tem memória de longo prazo. Onde você + +0:18:15.120,0:18:17.120 +Conheces-te + +0:18:17.700,0:18:22.129 +Onde todo o seu pensamento é feito e todas essas coisas e há um + +0:18:24.720,0:18:26.460 +Você sabe + +0:18:26.460,0:18:28.879 +Um pedaço de neurônios chamado hipocampo, que é uma espécie de + +0:18:29.100,0:18:32.359 +São duas formações no meio do cérebro e elas meio que enviam + +0:18:34.320,0:18:36.650 +Fios para praticamente todo o córtex e + +0:18:37.110,0:18:44.390 +O hipocampo é pensado para ser usado como uma memória de curto prazo. Então, você pode apenas saber, lembrar de coisas por um tempo relativamente curto + +0:18:45.950,0:18:47.450 +O predominante + +0:18:47.450,0:18:53.530 +teoria é que quando você dorme e sonha, há muita informação que está sendo transferida do seu + +0:18:53.810,0:18:56.800 +hipocampo ao seu córtex para ser solidificado na memória de longo prazo + +0:18:59.000,0:19:01.090 +Porque o hipocampo tem capacidade limitada + +0:19:04.520,0:19:08.859 +Quando você fica senil como você fica muito velho, muitas vezes seu hipocampo encolhe e + +0:19:09.620,0:19:13.570 +Você não tem mais memória de curto prazo. Então você continua repetindo as mesmas histórias para as mesmas pessoas + +0:19:14.420,0:19:16.420 +Ok, é muito comum + +0:19:19.430,0:19:25.930 +Ou você vai a uma sala para fazer alguma coisa e, quando chega à sala, esqueceu para que estava lá. + +0:19:29.450,0:19:31.869 +Isso começa a acontecer quando você tem 50 anos, a propósito + +0:19:36.290,0:19:40.390 +Então, eu não me lembro do que eu disse na semana passada de duas semanas atrás, hum + +0:19:41.150,0:19:44.950 +Ok, mas enfim, rede de memória, aqui está a ideia de rede de memória + +0:19:46.340,0:19:50.829 +Você tem uma entrada para a rede de memória. Vamos chamá-lo de X e pensar nele como um endereço + +0:19:51.770,0:19:53.770 +Da memória, ok + +0:19:53.930,0:19:56.409 +O que você vai fazer é comparar esse X + +0:19:58.040,0:20:03.070 +Com um monte de vetores, vamos chamar K + +0:20:08.180,0:20:10.180 +Então k₁ k₂ k₃ + +0:20:12.890,0:20:18.910 +Ok, então você compara esses dois vetores e a maneira como você os compara é via produto escalar muito simples + +0:20:28.460,0:20:33.460 +Ok, agora você tem os três produtos escalares de todos os três Ks com o X + +0:20:34.730,0:20:37.990 +Eles são valores escalares, você sabe conectá-los a um softmax + +0:20:47.630,0:20:50.589 +Então, o que você obtém são três números entre 0 e 1 que somam 1 + +0:20:53.840,0:20:59.259 +O que você faz com esses você tem 3 outros vetores que eu vou chamar de V + +0:21:00.680,0:21:02.680 +v₁, v₂ e v₃ + +0:21:03.770,0:21:07.120 +E o que você faz é multiplicar + +0:21:08.990,0:21:13.570 +Esses vetores por esses escalares, então isso é muito parecido com o mecanismo de atenção que acabamos de falar + +0:21:17.870,0:21:20.950 +Ok, e você resumiu + +0:21:27.440,0:21:34.870 +Ok, então pegue um X compare X com cada um dos K ​​cada um dos Ks que são chamados de chaves + +0:21:39.170,0:21:44.500 +Você obtém vários coeficientes entre zero e um que somam um e, em seguida, calcula uma combinação linear dos valores + +0:21:45.260,0:21:47.260 +Esses são vetores de valor + +0:21:50.510,0:21:51.650 +E + +0:21:51.650,0:21:53.150 +Soma-os + +0:21:53.150,0:22:00.400 +Ok, então imagine que uma das chaves corresponda exatamente a X, você terá um coeficiente grande aqui e coeficientes pequenos ali + +0:22:00.400,0:22:06.609 +Assim, a saída do sistema será essencialmente V2, se K 2 corresponder a X, a saída será essencialmente V 2 + +0:22:08.060,0:22:09.500 +OK + +0:22:09.500,0:22:11.890 +Então esta é uma memória associativa endereçável + +0:22:12.620,0:22:19.419 +A memória associativa é exatamente onde você tem chaves com valores e se sua entrada corresponder a uma chave você obtém o valor aqui + +0:22:19.420,0:22:21.420 +É uma espécie de versão soft diferenciável disso + +0:22:26.710,0:22:28.710 +Então você pode + +0:22:29.019,0:22:34.559 +você pode voltar a propagar para isso você pode escrever nessa memória alterando os vetores V ou + +0:22:34.929,0:22:38.609 +Mesmo mudando os vetores K. Você pode alterar os vetores V por gradiente descendente + +0:22:39.489,0:22:45.598 +Ok, então se você quiser que a saída da memória seja algo em particular, retropropagando o gradiente por meio disso + +0:22:47.019,0:22:52.259 +você vai mudar o V atualmente ativo para o que for necessário para o + +0:22:53.530,0:22:55.530 +para a saída + +0:22:56.050,0:22:58.050 +Então naqueles papéis + +0:22:59.800,0:23:02.460 +O que eles fizeram foi eu + +0:23:03.969,0:23:06.299 +Significa que há uma série de papéis em cada rede, mas + +0:23:08.409,0:23:11.879 +O que eles fizeram foi exatamente o cenário que acabei de explicar onde você meio que + +0:23:12.909,0:23:16.319 +Conte uma história para um sistema, então dê uma sequência de frases + +0:23:17.530,0:23:22.800 +Essas frases são codificadas em vetores passando por uma rede neural que não é pré-treinada, você sabe + +0:23:25.269,0:23:29.279 +apenas através do treinamento de todo o sistema, ele descobre como codificar isso + +0:23:30.039,0:23:35.009 +e então essas frases são escritas na memória deste tipo e + +0:23:35.829,0:23:41.129 +Então, quando você faz uma pergunta ao sistema, você codifica a pergunta na entrada de uma rede neural, a rede neural produz + +0:23:41.130,0:23:44.999 +Um X para a memória a memória retorna um valor + +0:23:46.510,0:23:47.590 +E + +0:23:47.590,0:23:49.480 +Então você usa esse valor + +0:23:49.480,0:23:54.329 +e o estado anterior da rede para reacessar a memória, você pode fazer isso várias vezes e + +0:23:54.550,0:23:58.139 +Você treina toda essa rede para produzir ou uma resposta para sua pergunta + +0:23:59.139,0:24:03.748 +E se você tem muitos e muitos cenários muitas e muitas perguntas ou também muitas respostas + +0:24:04.119,0:24:10.169 +O que eles fizeram neste caso, gerando artificialmente histórias, perguntas e respostas + +0:24:11.440,0:24:12.940 +essa coisa na verdade + +0:24:12.940,0:24:15.989 +aprende a armazenar histórias e + +0:24:16.780,0:24:18.760 +responder a perguntas + +0:24:18.760,0:24:20.409 +O que é bem incrível + +0:24:20.409,0:24:22.409 +Então essa é a rede de memória + +0:24:27.110,0:24:29.860 +Ok, então o primeiro passo é você calcular + +0:24:32.210,0:24:34.300 +Alfa I é igual + +0:24:36.590,0:24:43.899 +KI transpõe X. Ok, apenas um produto escalar. Ok, e então você calcula + +0:24:48.350,0:24:51.519 +CI ou o vetor CI deve dizer + +0:24:54.530,0:24:57.579 +É a função softmax + +0:25:00.320,0:25:02.979 +Aplicado ao vetor de alfas, ok + +0:25:02.980,0:25:07.840 +Então os C's estão entre 0 e 1 e somam 1 e então a saída do sistema + +0:25:09.080,0:25:11.080 +é + +0:25:11.150,0:25:13.360 +soma sobre I de + +0:25:14.930,0:25:16.930 +Lá + +0:25:17.240,0:25:21.610 +Vi onde Vis são os vetores de valor. OK. Essa é a memória + +0:25:30.420,0:25:34.489 +Sim, sim, sim, absolutamente + +0:25:37.140,0:25:38.640 +Na verdade + +0:25:38.640,0:25:41.869 +Não, quero dizer, tudo que você precisa é que tudo seja codificado como vetores? + +0:25:42.660,0:25:48.200 +Certo e então corra para o seu convnet favorito, você pega um vetor que representa a imagem e aí você pode fazer o QA + +0:25:50.880,0:25:52.880 +Sim, quero dizer assim + +0:25:53.490,0:25:57.050 +Você pode imaginar muitas aplicações disso, em particular + +0:25:58.110,0:26:00.110 +Quando a aplicação é eu + +0:26:00.690,0:26:02.690 +Significa que você pode, você pode pensar + +0:26:06.630,0:26:09.109 +Você sabe, pense nisso como uma espécie de memória + +0:26:11.160,0:26:14.000 +E então você pode ter algum tipo de rede neural + +0:26:16.020,0:26:16.970 +Que você sabe + +0:26:16.970,0:26:24.230 +ele pega uma entrada e então produz um endereço para a memória pega um valor de volta e + +0:26:25.050,0:26:27.739 +Então continua crescendo e eventualmente produz uma saída + +0:26:28.830,0:26:30.830 +Isso era muito parecido com um computador + +0:26:31.050,0:26:33.650 +OK. Bem, a rede neural aqui é a + +0:26:34.920,0:26:37.099 +a CPU a ULA a CPU + +0:26:37.680,0:26:43.099 +Ok, e a memória é apenas uma memória externa que você pode acessar sempre que precisar, ou você pode escrever nela se quiser + +0:26:43.890,0:26:49.040 +É uma rede recorrente neste caso. Você pode desdobrá-lo no tempo, que é o que esses caras fizeram + +0:26:51.330,0:26:52.650 +E + +0:26:52.650,0:26:58.009 +E então há pessoas que meio que imaginaram que você poderia realmente construir computadores diferenciáveis ​​a partir disso + +0:26:58.410,0:27:03.530 +Existe algo chamado máquina de Turing neural, que é essencialmente uma forma disso onde a memória não é desse tipo + +0:27:03.530,0:27:07.040 +É uma espécie de fita macia como em uma máquina de Turing normal + +0:27:07.890,0:27:14.030 +Isso é em algum lugar da mente profunda que a história interessante sobre isso é que as pessoas do Facebook publicaram + +0:27:14.760,0:27:19.909 +O artigo sobre a rede de memória no arxiv e três dias depois + +0:27:22.110,0:27:24.110 +As pessoas da mente profunda colocaram um papel + +0:27:25.290,0:27:30.679 +Sobre a máquina de Turing neural e a razão pela qual eles colocaram três dias depois é que eles estão trabalhando na máquina de Turing e + +0:27:31.350,0:27:32.640 +em seu + +0:27:32.640,0:27:37.160 +Tradição, eles mantêm o projeto em segredo, a menos que você saiba, até que eles possam fazer um grande sucesso + +0:27:37.770,0:27:40.699 +Mas lá eles foram pegos, então eles colocaram o papel no arxiv + +0:27:45.060,0:27:50.539 +Eventualmente, eles fizeram um grande barulho com outro com um papel, mas isso foi um ano depois ou mais + +0:27:52.230,0:27:54.230 +Então o que aconteceu + +0:27:55.020,0:28:01.939 +desde então é que as pessoas meio que pegaram nesse módulo essa ideia de que você compara entradas com chaves e + +0:28:02.550,0:28:04.550 +que lhe dá coeficientes e + +0:28:04.950,0:28:07.819 +Você sabe que você produz valores + +0:28:08.520,0:28:09.990 +Como + +0:28:09.990,0:28:14.449 +Uma espécie de módulo essencial em uma rede neural e é basicamente onde o transformador está + +0:28:15.060,0:28:18.049 +então um transformador é basicamente uma rede neural na qual + +0:28:19.290,0:28:21.290 +Cada grupo de neurônios é um desses + +0:28:21.720,0:28:29.449 +É um monte de memórias. Essencialmente. Há um pouco mais de reviravolta nisso. Ok, mas isso é meio que o básico, a ideia básica + +0:28:32.460,0:28:34.460 +Mas você vai ouvir sobre isso + +0:28:34.980,0:28:36.750 +em uma semana Ah + +0:28:36.750,0:28:38.250 +em duas semanas + +0:28:38.250,0:28:40.140 +uma semana uma semana + +0:28:40.140,0:28:42.140 +Ok mais alguma pergunta? + +0:28:44.010,0:28:46.640 +Frio. Tudo bem. Muito obrigado \ No newline at end of file diff --git a/docs/pt/week06/practicum06.sbv b/docs/pt/week06/practicum06.sbv new file mode 100644 index 000000000..0cdbe1765 --- /dev/null +++ b/docs/pt/week06/practicum06.sbv @@ -0,0 +1,1742 @@ +0:00:00.030,0:00:03.959 +então hoje vamos cobrir muitos materiais, então tentarei não + +0:00:03.959,0:00:08.309 +correr, mas ontem jovem me pegou completamente tão jovem falou exatamente + +0:00:08.309,0:00:15.269 +as mesmas coisas que eu queria falar hoje então eu vou um pouco mais rápido por favor devagar + +0:00:15.269,0:00:18.210 +me para baixo se você realmente está de alguma forma perdido ok + +0:00:18.210,0:00:21.420 +então vou tentar ser um pouco mais rápido que o senhor + +0:00:21.420,0:00:26.250 +então hoje vamos falar sobre redes neurais recorrentes registram neurais + +0:00:26.250,0:00:31.050 +redes são um tipo de arquitetura que podemos usar para lidar com + +0:00:31.050,0:00:37.430 +sequências de dados o que são sequências que tipo de sinal é uma sequência + +0:00:39.890,0:00:44.219 +temporal é um componente temporal, mas já vimos dados com tempo + +0:00:44.219,0:00:49.350 +componente como eles são chamados qual dimensional qual é a dimensão + +0:00:49.350,0:00:55.320 +desse tipo de sinal, então na lição da rede convolucional que vimos + +0:00:55.320,0:00:59.969 +que um sinal pode ser um este sinal para este sinal 3d de sinal com base no + +0:00:59.969,0:01:06.270 +domínio e o domínio é o que você mapeia para ir para a direita para que o tratamento temporal + +0:01:06.270,0:01:10.580 +seqüências sequenciais de dados está basicamente lidando com um dos dados + +0:01:10.580,0:01:15.119 +porque o domínio será apenas o eixo temporal, mas você pode + +0:01:15.119,0:01:18.689 +também use RNN para lidar com você sabe dados bidimensionais que você tem duplo + +0:01:18.689,0:01:28.049 +Direção ok ok então esta é uma rede neural clássica no diagrama + +0:01:28.049,0:01:33.299 +ou seja, estou acostumado a desenhar onde represento cada um, neste caso, um monte de + +0:01:33.299,0:01:37.590 +neurônios como cada um deles é um vetor e, por exemplo, o X é meu vetor de entrada + +0:01:37.590,0:01:42.450 +está em rosa como de costume, então eu tenho minha camada oculta em um verde no centro + +0:01:42.450,0:01:46.200 +então eu tenho minha camada final de pista azul, que é a rede de saída, então + +0:01:46.200,0:01:52.320 +esta é uma rede neural de três camadas no meu para minha notação e, portanto, se alguns de vocês + +0:01:52.320,0:01:57.960 +estão familiarizados com a eletrônica digital é como falar sobre um + +0:01:57.960,0:02:03.329 +lógica combinatória sua saída atual depende apenas da entrada atual e + +0:02:03.329,0:02:08.420 +é isso, não há nenhuma outra entrada em vez disso, quando + +0:02:08.420,0:02:12.590 +estamos falando sobre nossos homens, vamos falar sobre algo que parece + +0:02:12.590,0:02:17.420 +assim, neste caso, nossa saída aqui no lado direito depende do + +0:02:17.420,0:02:21.860 +entrada atual e no estado do sistema e novamente se você é um rei de + +0:02:21.860,0:02:26.750 +eletrônica digital isso é simplesmente lógica seqüencial enquanto você tem um + +0:02:26.750,0:02:31.580 +estado interno a cebola é a dimensão flip-flop se você não tem idéia + +0:02:31.580,0:02:37.040 +que flip-flop você conhece, veja só, é apenas uma unidade de memória muito básica em + +0:02:37.040,0:02:41.810 +eletrônica digital, no entanto, esta é a única diferença logo no primeiro + +0:02:41.810,0:02:45.290 +caso você tenha uma saída que é apenas função da entrada no segundo caso + +0:02:45.290,0:02:49.580 +você tem uma saída que é função da entrada e do estado do sistema + +0:02:49.580,0:02:54.130 +ok, essa é a grande diferença sim, baunilha é um termo americano para dizer + +0:02:58.040,0:03:04.670 +é avião não tem um gosto que americano desculpe eu tento ser o mais + +0:03:04.670,0:03:11.390 +Americano eu posso na Itália você se sente tomado um sorvete que não tem + +0:03:11.390,0:03:15.950 +prove vai ser fior di latte que é leite prove aqui não temos leite + +0:03:15.950,0:03:20.049 +testes eles têm sabor de baunilha que é o sorvete simples + +0:03:20.049,0:03:28.360 +ok americanos desculpe tudo bem então oh então vamos ver o que faz + +0:03:28.360,0:03:32.760 +isso muda com a representação jovem tão jovem desenha esse tipo de pequeno + +0:03:32.760,0:03:38.170 +coisas estranhas aqui que representam um mapeamento entre um tensor TENS para outro + +0:03:38.170,0:03:41.800 +pintor de um vetor para outro vetor, então você tem o seu + +0:03:41.800,0:03:46.630 +o vetor de entrada X será mapeado através deste item aqui para este oculto + +0:03:46.630,0:03:50.620 +representação de modo que realmente represente minha bela transformação para que minha + +0:03:50.620,0:03:54.130 +rotação Mais esta pergunta, então você tem a representação do aquecedor que você + +0:03:54.130,0:03:57.850 +ter outra rotação é uma questão, então você obtém a saída final da mesma forma + +0:03:57.850,0:04:03.220 +no diagrama recorrente você pode ter essas coisas adicionais isso é bom + +0:04:03.220,0:04:06.640 +esmagamento de transformação que é como um módulo de atraso com uma transformação final + +0:04:06.640,0:04:10.900 +excursão e agora você tem a última transformação afim e esmagamento + +0:04:10.900,0:04:18.100 +certo essas coisas estão fazendo barulho ok desculpe tudo bem então qual é o primeiro + +0:04:18.100,0:04:24.250 +caso o primeiro caso é este é um vetor para sequenciar, então inserimos uma bolha no + +0:04:24.250,0:04:28.270 +maravilha rosa e então você vai ter essa evolução do estado interno de + +0:04:28.270,0:04:33.070 +o sistema o verde e então, à medida que o estado do sistema evolui, você pode ser + +0:04:33.070,0:04:38.470 +cuspindo em cada carimbo de hora uma saída específica o que pode ser um exemplo + +0:04:38.470,0:04:43.240 +deste tipo de arquitetura para que este possa ser o seguinte, minha entrada vai + +0:04:43.240,0:04:46.750 +ser uma dessas imagens e, em seguida, a saída será uma sequência de + +0:04:46.750,0:04:53.140 +caracteres que representam a descrição em inglês de qualquer que seja essa entrada + +0:04:53.140,0:04:57.940 +por exemplo, no centro, quando temos uma manada de elefantes, então a última manada + +0:04:57.940,0:05:03.880 +de elefantes andando por um campo de grama seca, então está muito, muito bem + +0:05:03.880,0:05:09.130 +refinado, então você tem no centro aqui, por exemplo, dois cães brincam + +0:05:09.130,0:05:15.640 +na grama talvez haja três, mas tudo bem, eles jogam, eles estão jogando + +0:05:15.640,0:05:20.500 +a grama certa, então é legal, neste caso você conhece um parque de motos vermelho + +0:05:20.500,0:05:24.610 +o lado da estrada parece mais rosa ou você sabe um pouco + +0:05:24.610,0:05:30.490 +soprar uma garotinha no rosa que está soprando bolhas que ela não está + +0:05:30.490,0:05:35.650 +soprando direito qualquer coisa lá tudo bem e então você também tem você sabe mesmo + +0:05:35.650,0:05:41.560 +mais exemplos errados certo, então você tem como ônibus escolar amarelo estacionado no + +0:05:41.560,0:05:44.050 +estacionamento bem, é CL hum, mas não é uma escola + +0:05:44.050,0:05:49.860 +ônibus, então pode estar falhando também, mas eu também posso fazer um muito, muito legal, você sabe + +0:05:49.860,0:05:56.470 +você também pode ter um desempenho muito bom, então isso foi de um vetor de entrada que é B para + +0:05:56.470,0:06:01.720 +exemplo de representação da minha imagem para uma sequência de símbolos que são D para + +0:06:01.720,0:06:05.620 +exemplos de caracteres ou palavras que estão fazendo aqui minha frase em inglês ok + +0:06:05.620,0:06:11.440 +claro até agora sim ok outro tipo de uso que você pode ter é talvez o + +0:06:11.440,0:06:17.560 +seguindo, então você terá a sequência dois vetores finais ok, então eu não me importo + +0:06:17.560,0:06:22.120 +sobre as sequências intermediárias, então tudo bem, o canto superior direito é chamado de Auto regressivo + +0:06:22.120,0:06:26.590 +rede e rede regressiva externa é uma rede que está emitindo uma saída + +0:06:26.590,0:06:29.950 +dado que você sente como entrada a saída anterior ok + +0:06:29.950,0:06:33.700 +então isso é chamado de Auto regressivo, você tem esse tipo de parte maluca no + +0:06:33.700,0:06:37.780 +rede no lado esquerdo, em vez disso, fornecerei várias sequências + +0:06:37.780,0:06:40.140 +sim, essa vai ser a tradução em inglês + +0:06:51.509,0:06:55.380 +então você tem uma sequência de palavras que vão compor sua frase final + +0:06:55.380,0:07:00.330 +é azul lá você pode pensar em um índice em um dicionário e então cada + +0:07:00.330,0:07:03.300 +azul vai lhe dizer qual palavra você vai escolher em um índice + +0:07:03.300,0:07:09.780 +dicionário certo então este é um ônibus escolar certo então oh sim um ônibus escolar amarelo você + +0:07:09.780,0:07:14.940 +vá para um índice de a, então você tem o segundo índice, você pode descobrir que é amarelo + +0:07:14.940,0:07:17.820 +e, em seguida, a caixa da escola para a direita, então a sequência aqui será + +0:07:17.820,0:07:22.590 +representando a sequência de palavras que o modelo está do outro lado lá + +0:07:22.590,0:07:26.460 +a esquerda você terá em vez disso, continuo alimentando uma sequência de símbolos e + +0:07:26.460,0:07:30.750 +só no final eu vou olhar qual é a minha saída final o que pode ser um + +0:07:30.750,0:07:36.150 +aplicação deste, então algo que yun também mencionou era diferente, então vamos + +0:07:36.150,0:07:40.789 +ver se consigo fazer com que minha rede compile Python ou para um piloto aberto próprio + +0:07:40.789,0:07:45.599 +interpretação, então neste caso eu tenho minha entrada atual que alimento minha rede + +0:07:45.599,0:07:54.979 +que será J igual a 8580 para então para X na faixa de oito alguns - J 920 + +0:07:54.979,0:07:59.430 +blá blá blá e depois imprima este e então minha rede vai ser + +0:07:59.430,0:08:04.860 +encarregado de apenas você sabe me dar vinte e cinco mil e onze ok então + +0:08:04.860,0:08:09.210 +esta é a saída final de um programa e eu apliquei na rede para poder + +0:08:09.210,0:08:13.860 +para me enviar a saída correta, a correta na sua solução deste programa + +0:08:13.860,0:08:18.330 +ou coisas ainda mais complicadas, por exemplo, posso fornecer uma sequência de + +0:08:18.330,0:08:21.900 +outros símbolos que serão oitenta e oito mil e oitocentos + +0:08:21.900,0:08:26.669 +trinta e sete então eu tenho C vai ser algo então eu tenho que imprimir este + +0:08:26.669,0:08:33.360 +se algo que é sempre verdadeiro como o outro e então você conhece a saída + +0:08:33.360,0:08:38.849 +deve ser doze mil oito 184 certo para que você possa treinar uma rede neural para + +0:08:38.849,0:08:42.690 +fazer essas operações para que você alimente uma sequência de símbolos e depois no + +0:08:42.690,0:08:48.870 +saída você apenas impõe que o destino final deve ser um valor específico ok + +0:08:48.870,0:08:56.190 +e essas coisas fazendo barulho ok talvez eu seja melhor + +0:08:56.190,0:09:02.589 +tudo bem, então o que vem a seguir será, por exemplo, uma sequência para vetor + +0:09:02.589,0:09:07.210 +para sequenciar isso costumava ser a maneira padrão de executar a linguagem de comprimento + +0:09:07.210,0:09:13.000 +tradução para que você comece com uma sequência de símbolos aqui mostrados em rosa para que você + +0:09:13.000,0:09:17.290 +tem uma sequência de entradas, então tudo é condensado nesse tipo + +0:09:17.290,0:09:23.020 +da idade final que é este H aqui que vai ser de alguma forma o meu conceito + +0:09:23.020,0:09:27.880 +certo, então eu tenho uma frase, eu espremo a informação temporal da frase em apenas + +0:09:27.880,0:09:31.600 +um vetor que está representando o significado da mensagem que eu gostaria de enviar + +0:09:31.600,0:09:36.310 +e então eu recebo esse significado em qualquer representação desenrolada de volta + +0:09:36.310,0:09:41.380 +um idioma diferente né pra eu codificar não sei hoje estou muito feliz + +0:09:41.380,0:09:47.350 +em inglês como uma sequência de palavras e então você sabe que pode fazer com que o LG Sonoma + +0:09:47.350,0:09:53.170 +Felicia e depois falo fora da Tailândia hoje ou o que quer que seja agora hoje estou + +0:09:53.170,0:09:58.480 +muito cansado Jin Chen anda han lei ou o que quer que seja ok então + +0:09:58.480,0:10:02.020 +novamente você tem algum tipo de codificação, então você tem um compactado + +0:10:02.020,0:10:08.110 +representação e então você fica como a decodificação dada a mesma compactação + +0:10:08.110,0:10:15.040 +versão ok e então, por exemplo, acho que a tradução de idiomas novamente recentemente + +0:10:15.040,0:10:20.709 +vimos transformadores e muitas coisas como nos últimos tempos, então estamos + +0:10:20.709,0:10:25.300 +vou cobrir isso na próxima lição, eu acho, mas isso costumava ser o estado de + +0:10:25.300,0:10:31.000 +a arte até uns dois anos atrás e aqui você pode ver que se você realmente verificar + +0:10:31.000,0:10:38.950 +se você fizer um PCA sobre o espaço latente você tem que as palavras são agrupadas por + +0:10:38.950,0:10:43.630 +semântica ok, então, se ampliarmos nessa região, veremos isso em + +0:10:43.630,0:10:48.400 +o que no mesmo local você encontra todos os valores dezembro fevereiro novembro + +0:10:48.400,0:10:52.750 +certo, se você colocar um pouco de foco em uma região diferente, você obtém alguns + +0:10:52.750,0:10:55.250 +dias próximos quilômetros e assim por diante, então + +0:10:55.250,0:11:00.230 +local diferente terá algum significado comum específico que você conhece para que possamos + +0:11:00.230,0:11:05.780 +basicamente veja neste caso como treinando essas redes você sabe apenas + +0:11:05.780,0:11:09.680 +com símbolos eles vão pegar algumas semânticas específicas + +0:11:09.680,0:11:16.130 +você conhece os recursos, neste caso, você pode ver como se houvesse um vetor, então o + +0:11:16.130,0:11:20.900 +vetor que está conectando mulheres a homens será o mesmo vetor que está bem + +0:11:20.900,0:11:27.590 +mulher - homem que é esse eu acho que vai ser igual a rainha - rei certo e + +0:11:27.590,0:11:32.890 +então sim, está correto e você terá a mesma distância neste + +0:11:32.890,0:11:37.730 +espaço de incorporação será aplicado a coisas que são femininas e masculinas para + +0:11:37.730,0:11:43.370 +exemplo ou no outro caso você entrou e andou nadando e pântano assim + +0:11:43.370,0:11:47.960 +você sempre tem isso você sabe a transformação linear específica que você pode aplicar em + +0:11:47.960,0:11:53.690 +para ir de um tipo de palavra para outro ou este você tem a + +0:11:53.690,0:11:59.180 +ligação entre as cidades e as capitais tudo certo então mais um certo eu + +0:11:59.180,0:12:05.210 +pense no que está faltando no quadro geral aqui é um quadro geral porque + +0:12:05.210,0:12:09.560 +é tão grande não não é uma imagem tão grande porque é a visão geral ok + +0:12:09.560,0:12:18.590 +você não entendeu a piada está tudo bem o que está faltando aqui vetor para buscar sem tudo bem + +0:12:18.590,0:12:23.330 +bom, mas não, porque você ainda pode usar o outro, então você tem este + +0:12:23.330,0:12:27.830 +vetor é sequência para sequência correta, então este é você começar a alimentar dentro + +0:12:27.830,0:12:31.580 +entradas você começa a produzir algo certo o que pode ser um exemplo disso + +0:12:31.580,0:12:38.900 +coisas, então se você tem um telefone Nokia e usa o t9, você conhece essas coisas de + +0:12:38.900,0:12:43.100 +20 anos atrás você tem basicamente sugestões sobre qual é a sua digitação + +0:12:43.100,0:12:47.150 +você está digitando certo, então este seria um tipo dessas sugestões, como uma + +0:12:47.150,0:12:50.570 +tipo dessa arquitetura à medida que você recebe sugestões enquanto digita coisas + +0:12:50.570,0:12:57.290 +através ou você pode ter como fala para legendas né eu falei e você tem o + +0:12:57.290,0:13:02.520 +coisas abaixo ou algo muito legal que é + +0:13:02.520,0:13:08.089 +o seguinte então eu começo a escrever aqui os anéis de Saturno brilham enquanto o + +0:13:08.089,0:13:16.260 +gelo duro dois homens se olham hmm ok eles eram inimigos mas o servidor + +0:13:16.260,0:13:20.100 +os robôs não estavam bem ok espere então esta rede foi treinada em alguns + +0:13:20.100,0:13:24.360 +romances de ficção científica e, portanto, você pode simplesmente digitar algo e deixar a rede + +0:13:24.360,0:13:28.290 +começar a enviar algumas sugestões para você, para que você saiba se não sabe como + +0:13:28.290,0:13:34.620 +escreva um livro, então você pode saber, peça ao seu computador para ajudá-lo, ok + +0:13:34.620,0:13:39.740 +isso é tão legal ou mais um que eu realmente gosto este é fantástico eu acho + +0:13:39.740,0:13:45.959 +você deveria ler, leia, eu acho, então você coloca algum tipo de entrada lá como o + +0:13:45.959,0:13:51.630 +cientista nomeou sozinho o que é ou o prompt certo para que você coloque no + +0:13:51.630,0:13:56.839 +o prompt superior e então você sabe que esta rede começa a escrever sobre muito + +0:13:56.839,0:14:05.690 +unicórnios interessantes com vários chifres são chamados de chifres, diga unicórnio certo, ok + +0:14:05.690,0:14:09.480 +tudo bem, que legal, confira mais tarde e você pode tirar uma captura de tela + +0:14:09.480,0:14:14.970 +a tela de qualquer maneira, era como um colírio para os olhos, para que você saiba + +0:14:14.970,0:14:21.089 +com fome agora vamos entrar no PTT que é a coisa que eles não gostam muito + +0:14:21.089,0:14:27.390 +o PTT de ontem disse ok ok vamos ver como isso funciona bem então no + +0:14:27.390,0:14:31.620 +lado esquerdo vemos novamente este vetor no meio na representação a saída + +0:14:31.620,0:14:35.520 +para uma transformação fina e então temos as equações clássicas certas + +0:14:35.520,0:14:42.450 +tudo bem, então vamos ver como essas coisas são semelhantes ou não semelhantes e você não pode ver + +0:14:42.450,0:14:46.620 +qualquer coisa então nos próximos dois segundos eu vou querer um minuto eu vou desligar o + +0:14:46.620,0:14:51.300 +luzes, então eu as ligo [Música] + +0:14:51.300,0:14:55.570 +ok agora você pode ver algo certo então vamos ver quais são as perguntas de + +0:14:55.570,0:15:00.490 +essa nova arquitetura não se levante você vai se esmagar + +0:15:00.490,0:15:04.270 +tudo bem, então você tem aqui a representação oculta agora vai haver isso + +0:15:04.270,0:15:10.000 +função não linear desta rotação de uma versão de pilha da minha entrada que eu + +0:15:10.000,0:15:15.520 +anexou a configuração anterior da camada oculta ok e então esta é uma + +0:15:15.520,0:15:19.420 +notação compacta muito boa, é só colocar os dois vetores um em cima + +0:15:19.420,0:15:24.640 +um ao outro e então eu assino atribuo eu soma o viés eu também e defino inicial + +0:15:24.640,0:15:29.920 +condicionar meu H inicial será 0, então no início sempre que eu tiver t = 1 + +0:15:29.920,0:15:34.360 +esse material vai ser resolvido é um vetor de zeros e então eu tenho isso + +0:15:34.360,0:15:39.880 +matriz Wh serão duas matrizes separadas, então às vezes você vê isso como + +0:15:39.880,0:15:48.130 +pergunta é Wₕₓ vezes x mais Wₕₕ vezes h[t-1], mas você também pode descobrir + +0:15:48.130,0:15:52.450 +que se você estocar essas duas matrizes você sabe que uma está ligada à outra que você + +0:15:52.450,0:15:56.620 +basta colocar essas duas linhas verticais em notação completamente equivalente, mas + +0:15:56.620,0:16:01.360 +parecia muito semelhante ao que tínhamos aqui, então a camada oculta é afim + +0:16:01.360,0:16:05.230 +transformação da camada interna de entrada é a transformação afim da entrada + +0:16:05.230,0:16:11.440 +e o valor anterior ok e então você tem a saída final que será + +0:16:11.440,0:16:20.140 +novamente minha rotação final então eu vou acender a luz então sem mágica até agora + +0:16:20.140,0:16:27.690 +certo você está bem certo você está comigo para balançar a cabeça e os outros + +0:16:27.690,0:16:34.930 +não sim tudo bem então este é simplesmente na mão direita + +0:16:34.930,0:16:40.330 +lado eu simplesmente desenrolo ao longo do tempo para que você possa ver como as coisas não são muito + +0:16:40.330,0:16:43.990 +louco como este loop aqui não é realmente um loop isso é como um + +0:16:43.990,0:16:48.500 +conexão com o próximo passo certo para que em torno + +0:16:48.500,0:16:52.760 +seta significa que é apenas esta seta para a direita, então esta é uma rede neural, é dinkley a + +0:16:52.760,0:16:57.950 +rede neural que é estendida em comprimento e não apenas em um em um + +0:16:57.950,0:17:01.639 +espessura certa, então você tem uma rede que vai nessa direção de entrada e + +0:17:01.639,0:17:05.600 +saída, mas como você pode pensar, houve uma entrada estendida e esta foi uma + +0:17:05.600,0:17:10.220 +saída estendida enquanto todos esses pesos intermediários são todos compartilhados + +0:17:10.220,0:17:14.120 +então todos esses pesos são os mesmos pesos e então você usa esse tipo de + +0:17:14.120,0:17:17.510 +pesos compartilhados, por isso é semelhante a uma rede convolucional no sentido de que você + +0:17:17.510,0:17:21.410 +tinha esse parâmetro de compartilhamento em diferentes domínios de tempo porque você + +0:17:21.410,0:17:28.820 +suponha que haja algum tipo de estacionaridade à direita do sinal + +0:17:28.820,0:17:32.870 +sentido, então isso é um tipo de convolução, certo, você pode ver como isso é uma espécie de + +0:17:32.870,0:17:40.130 +convolução tudo bem então foi meio que você conhece um pouco da teoria que nós + +0:17:40.130,0:17:46.160 +já vi isso então vamos ver como isso funciona para um exemplo prático então neste + +0:17:46.160,0:17:51.830 +caso estamos apenas lendo este código aqui, então este é o modelo de linguagem mundial que você + +0:17:51.830,0:17:57.770 +pode encontrá-lo nos exemplos do PyTorch para que você tenha uma sequência de símbolos que eu tenho + +0:17:57.770,0:18:01.910 +apenas representado lá cada símbolo é como uma letra no alfabeto e então + +0:18:01.910,0:18:05.419 +a primeira parte vai ser basicamente dividindo este desta forma certo + +0:18:05.419,0:18:10.309 +então você preserva verticalmente no domínio do tempo, mas então eu divido o longo + +0:18:10.309,0:18:16.640 +sequência longa de tal forma que agora posso cortar posso usar as melhores apostas como se diz + +0:18:16.640,0:18:21.980 +computação, então a primeira coisa que você tem o melhor tamanho será 4 neste caso + +0:18:21.980,0:18:27.410 +e então eu vou entrar no meu primeiro lote e então vou forçar o + +0:18:27.410,0:18:33.650 +rede para poder, então esta será minha melhor propagação de volta ao longo do tempo + +0:18:33.650,0:18:38.270 +período e forçarei a rede a produzir a próxima sequência de caracteres + +0:18:38.270,0:18:44.510 +ok então dado que eu tenho a,b,c, vou forçar minha rede a dizer d dado que eu tenho + +0:18:44.510,0:18:50.000 +g,h,i, forçarei a rede a criar j. Dado m,n,o, + +0:18:50.000,0:18:54.980 +Eu quero p, dado s,t,u, eu quero v. Então, como você pode realmente fazer + +0:18:54.980,0:18:59.660 +certeza de que você entende o que estou dizendo sempre que puder prever meu próximo + +0:18:59.660,0:19:04.010 +mundo você é realmente capaz de você sabe que basicamente já sabe o que eu sou + +0:19:04.010,0:19:11.720 +dizendo certo, sim, tentando prever uma próxima palavra que você vai + +0:19:11.720,0:19:15.170 +estar mostrando algum tipo de compreensão do que quer que seja este temporal + +0:19:15.170,0:19:22.700 +informações nos dados tudo bem, então depois de conseguirmos as camas que temos, então como + +0:19:22.700,0:19:26.510 +funciona, vamos ver se você sabe e um pouco de detalhe isso é + +0:19:26.510,0:19:30.650 +vai ser minha primeira saída vai ser um lote com quatro itens eu alimento isso + +0:19:30.650,0:19:34.220 +no canto mais próximo a noite toda e, em seguida, minha rede neural, chegamos a um + +0:19:34.220,0:19:39.740 +previsão da próxima amostra certa e eu forçarei essa a ser minha b,h,n,t + +0:19:39.740,0:19:47.450 +ok, então eu vou ter minha segunda entrada, vou fornecer a anterior + +0:19:47.450,0:19:53.420 +estado oculto para o RNN atual, sentirei isso por dentro e espero + +0:19:53.420,0:19:58.670 +obter a segunda linha da saída o destino certo e depois assim por diante, eu recebo + +0:19:58.670,0:20:03.410 +o próximo estado e desculpe a próxima entrada eu recebo o próximo estado e então eu vou + +0:20:03.410,0:20:07.700 +entrar na rede neural o RNN I que vou tentar forçar para obter o + +0:20:07.700,0:20:13.840 +alvo final ok até agora sim cada um vai ser a saída do + +0:20:18.730,0:20:28.280 +direito de rede neural recorrente da internet vou mostrar a equação antes que você tenha h[1] + +0:20:28.280,0:20:43.460 +sai deste um segundo a saída eu vou forçar a saída + +0:20:43.460,0:20:48.170 +na verdade, para ser meu alvo, minha próxima palavra na sequência de letras, então eu tenho + +0:20:48.170,0:20:52.610 +uma sequência de palavras força minha rede a prever qual é a próxima palavra dada a + +0:20:52.610,0:21:02.480 +palavra anterior sabe que h1 será alimentado aqui e você colocou a próxima palavra + +0:21:02.480,0:21:07.880 +a próxima palavra junto com o estado anterior e então você fará uma rotação de + +0:21:07.880,0:21:13.670 +a palavra anterior com uma anterior desculpe a nova palavra com o próximo estado o novo + +0:21:13.670,0:21:17.720 +palavra com o estado anterior você fará nossa rotação aqui encontre a transformação + +0:21:17.720,0:21:21.230 +certo e, em seguida, você aplica a não-linearidade para obter sempre um novo + +0:21:21.230,0:21:25.610 +palavra que é o X atual e aí você pega o estado anterior só para ver em + +0:21:25.610,0:21:30.650 +qual estado do sistema uma vez e, em seguida, você produz uma nova saída correta e, portanto, estamos + +0:21:30.650,0:21:35.000 +nesta situação aqui temos um monte de entradas eu tenho minha primeira entrada e depois + +0:21:35.000,0:21:39.200 +Eu recebo a primeira saída eu tenho essa memória interna que é enviada para frente e + +0:21:39.200,0:21:44.240 +então esta rede agora estará ciente do que aconteceu aqui e então eu insiro o + +0:21:44.240,0:21:49.450 +próxima entrada e assim por diante, recebo a próxima saída e forço a saída a ser a + +0:21:49.450,0:21:57.040 +saia aqui o valor dentro do lote ok tudo bem o que está faltando agora + +0:21:57.070,0:22:00.160 +[Música] isto é para desenho do PowerPoint + +0:22:02.890,0:22:08.370 +restrição tudo bem o que está acontecendo agora, então aqui eu vou enviar o + +0:22:08.370,0:22:13.300 +aqui acabei de desenhar uma seta com o h[T] final, mas há uma barra no + +0:22:13.300,0:22:16.780 +seta qual é a barra na seta quem pode + +0:22:16.780,0:22:27.100 +entenda o que a barra significa, claro que haverá, haverá o próximo + +0:22:27.100,0:22:31.570 +lote eles vão começar a partir daqui D e assim por diante este vai ser o meu + +0:22:31.570,0:22:46.690 +próximo lote d,j,p,ve,k,q,w ef,l,r,x. Esta barra aqui significa não voltar + +0:22:46.690,0:22:51.550 +propagar através de ok para que alguém chame o dot detach no Porsche + +0:22:51.550,0:22:56.560 +que vai parar o gradiente para ser propagado de volta para + +0:22:56.560,0:23:01.450 +para sempre tudo bem, então este diga, saiba disso e sempre que eu recebo, desculpe, não, não + +0:23:01.450,0:23:06.970 +gradiente de tal forma que, quando eu inserir o próximo gradiente, a primeira entrada aqui será + +0:23:06.970,0:23:11.530 +ser esse cara aqui e também claro sem gradiente para que não tenhamos + +0:23:11.530,0:23:17.170 +um comprimento infinito RNN ok faz sentido sim + +0:23:17.170,0:23:24.640 +não, eu suponho que é um sim, tudo bem, então desaparecendo e explodindo + +0:23:24.640,0:23:30.730 +gradientes nós tocamos neles também ontem, então novamente eu estou indo um + +0:23:30.730,0:23:35.620 +um pouco mais rápido para o usuário intent, então vamos ver como isso funciona + +0:23:35.620,0:23:40.390 +então geralmente para nossa rede neural recorrente você tem uma entrada você tem um + +0:23:40.390,0:23:45.160 +camada oculta e então você tem uma saída, então esse valor aqui como você obtém + +0:23:45.160,0:23:50.680 +esta informação por aqui o que o que esse R representa você + +0:23:50.680,0:23:55.840 +lembre-se da equação da camada oculta para que a nova camada oculta + +0:23:55.840,0:24:01.050 +ser a camada oculta anterior que giramos + +0:24:03.100,0:24:08.030 +tudo bem, então giramos a camada oculta anterior e como você gira oculta + +0:24:08.030,0:24:15.220 +matrizes de camadas corretas e, portanto, toda vez que você vê todos os anúncios na seta do bloco, há uma + +0:24:15.220,0:24:21.920 +rotação existe uma matriz agora se você sabe que esta matriz pode + +0:24:21.920,0:24:26.900 +altere o tamanho da sua saída final corretamente, então se você pensar em talvez + +0:24:26.900,0:24:31.190 +digamos que o determinante certo se o terminal for unitário é um mapeamento do + +0:24:31.190,0:24:34.610 +mesmas áreas para a mesma área, se for maior que um, eles serão + +0:24:34.610,0:24:39.560 +conhecendo esses radianos para ficar cada vez maior ou se for menor + +0:24:39.560,0:24:44.660 +do que eu vou fazer esses gradientes irem para zero sempre que você executar as costas + +0:24:44.660,0:24:48.920 +propagação nesta direção ok, então o problema aqui é que sempre que fazemos + +0:24:48.920,0:24:53.390 +é enviar gradientes de volta para que os ganhos sejam reduzidos assim + +0:24:53.390,0:24:57.800 +vai descer assim, então para baixo assim e para baixo assim + +0:24:57.800,0:25:01.610 +caminho e também por este caminho e assim por diante, para que os gradientes sejam + +0:25:01.610,0:25:06.380 +sempre indo contra a direção da seta em H ro tem uma matriz dentro + +0:25:06.380,0:25:11.510 +certo e novamente essa matriz afetará como esses gradientes se propagam e isso é + +0:25:11.510,0:25:18.590 +por que você pode ver aqui, embora tenhamos uma entrada muito brilhante que um gosta de obter + +0:25:18.590,0:25:23.720 +perdido por oh bem se você tem como um gradiente descendo aqui o gradiente + +0:25:23.720,0:25:30.410 +você sabe matar ao longo do tempo ok então como podemos consertar isso para consertar este nós simplesmente + +0:25:30.410,0:25:40.420 +remova as matrizes nesta operação horizontal faz sentido não sim não + +0:25:40.420,0:25:47.630 +o problema é que o próximo estado oculto fará com que você conheça sua própria entrada + +0:25:47.630,0:25:52.910 +memória vindo do passo anterior através de uma multiplicação de matrizes agora isso + +0:25:52.910,0:25:58.760 +a multiplicação de matrizes afetará o que vai ser o gradiente que vem no + +0:25:58.760,0:26:02.630 +outra direção ok então sempre que você tiver uma saída aqui você + +0:26:02.630,0:26:06.740 +ter uma derrota final agora você tem a nota que vai contra o + +0:26:06.740,0:26:12.050 +setas até a entrada o problema é que esse gradiente que vai + +0:26:12.050,0:26:16.910 +na direção oposta dessas setas será multiplicado pelo + +0:26:16.910,0:26:22.460 +matriz direita a transposição da matriz e novamente essas matrizes afetarão + +0:26:22.460,0:26:26.030 +qual é a norma geral desse gradiente certo e será tudo + +0:26:26.030,0:26:28.310 +matando você tem gradiente de fuga ou você está + +0:26:28.310,0:26:32.690 +vai ter explodir o gradiente que vai ser sempre que vai ser + +0:26:32.690,0:26:37.880 +sendo amplificado certo para evitar o que temos que evitar para que você + +0:26:37.880,0:26:41.960 +podemos ver que esta é uma rede muito profunda, então recorrentemente nossa rede onde o primeiro + +0:26:41.960,0:26:45.320 +redes profundas de volta à noite é na verdade e a palavra + +0:26:45.320,0:26:49.850 +profundidade estava realmente no tempo que e, claro, eles estavam enfrentando os mesmos problemas + +0:26:49.850,0:26:54.350 +enfrentamos com o aprendizado profundo nos dias modernos, onde ainda estávamos como + +0:26:54.350,0:26:58.450 +empilhando várias camadas, observamos que os gradientes se perdem à medida que + +0:26:58.450,0:27:05.750 +profundidade certa, então como resolvemos o gradiente se perdendo na profundidade em um + +0:27:05.750,0:27:08.770 +dias atuais pulando a conexão constante direito o + +0:27:11.270,0:27:15.530 +conexões do receptor que usamos e da mesma forma aqui podemos usar pular + +0:27:15.530,0:27:21.860 +conexões também quando descemos bem no tempo certo, então vamos ver como isso + +0:27:21.860,0:27:30.500 +funciona sim, então o problema é que o + +0:27:30.500,0:27:34.250 +gradientes estão apenas indo nos caminhos para trás de volta + +0:27:34.250,0:27:38.990 +[Música] bem, o gradiente tem que seguir o mesmo caminho + +0:27:38.990,0:27:42.680 +foi para a frente na direção oposta, quero dizer, você está computando + +0:27:42.680,0:27:46.970 +regra da cadeia, então se você tem uma função de uma função de uma função, então você apenas + +0:27:46.970,0:27:52.220 +usar essas funções para voltar à direita o ponto é que sempre que você tiver esses + +0:27:52.220,0:27:55.790 +gradientes voltando eles não terão que passar por matrizes, portanto, também + +0:27:55.790,0:28:01.250 +a parte direta não precisa passar pelas matrizes, o que significa que a + +0:28:01.250,0:28:07.310 +a memória não pode passar pela multiplicação de matrizes se você não quiser ter + +0:28:07.310,0:28:11.770 +este efeito quando você executa a propagação de volta ok + +0:28:14.050,0:28:19.420 +sim vai valer a pena trabalhar muito melhor eu mostro no próximo slide + +0:28:19.420,0:28:22.539 +[Música] mostra o próximo slide + +0:28:27.740,0:28:32.270 +então, como corrigimos bem esse problema em vez de usar um recurso neural recorrente + +0:28:32.270,0:28:36.650 +rede que vamos usar para rede neural recorrente ok, então o primeiro + +0:28:36.650,0:28:41.510 +RNN na primeira rede vai ser a que vai + +0:28:41.510,0:28:46.370 +da entrada para este estado intermediário, então eu tenho outras três redes + +0:28:46.370,0:28:51.410 +e cada um deles é representado por esses três símbolos 1 2 e 3. + +0:28:51.410,0:28:56.870 +ok pense nisso como nossa boca aberta e é como uma boca fechada ok tipo + +0:28:56.870,0:29:04.580 +o emoji ok então se você usar esse tipo de rede para rede neural recorrente + +0:29:04.580,0:29:09.740 +seja regular Rede você tem que ter por exemplo a partir da entrada que eu envio coisas + +0:29:09.740,0:29:14.390 +passa na boca aberta então chega aqui eu tenho a boca fechada aqui então + +0:29:14.390,0:29:18.920 +nada vai pra frente então eu vou ficar de boca aberta aqui pra que o + +0:29:18.920,0:29:23.600 +a história avança para que a história seja enviada para frente sem passar por um + +0:29:23.600,0:29:29.120 +multiplicação de matrizes de redes neurais, ele apenas passa pela nossa boca aberta e + +0:29:29.120,0:29:34.670 +todas as outras entradas encontram uma boca fechada para que o estado oculto não mude + +0:29:34.670,0:29:40.820 +novas entradas ok e então aqui você vai ter uma boca aberta aqui de tal forma que + +0:29:40.820,0:29:44.960 +você pode obter a saída final aqui, então a boca aberta continua aqui como + +0:29:44.960,0:29:48.560 +que você tem outra saída lá e, finalmente, você obtém a última fechada + +0:29:48.560,0:29:54.620 +boca no último agora se você executar back prop você terá os gradientes + +0:29:54.620,0:29:58.880 +fluindo pela boca aberta e você não obtém nenhum tipo de matriz + +0:29:58.880,0:30:04.400 +multiplicação, então agora vamos descobrir como essas bocas abertas são representadas + +0:30:04.400,0:30:10.010 +como eles são instanciados em termos de matemática é um design claro + +0:30:10.010,0:30:13.130 +agora estamos usando bocas abertas e fechadas e cada uma dessas bocas + +0:30:13.130,0:30:17.880 +é mais o primeiro cara aqui que conecta a entrada ao oculto são + +0:30:17.880,0:30:25.580 +brn termina então isso aqui que é uma rede recorrente fechada é simplesmente para + +0:30:25.580,0:30:32.060 +rede neural recorrente normal combinada de maneira inteligente, de modo que você tenha + +0:30:32.060,0:30:37.920 +interação multiplicativa e não interação de matrizes está claro até agora + +0:30:37.920,0:30:42.000 +isso é como a intuição eu não te mostrei como tudo bem então vamos descobrir + +0:30:42.000,0:30:48.570 +quem fez isso e como funciona bem, então vamos ver agora aqueles longos + +0:30:48.570,0:30:55.530 +memória de termo ou redes neurais recorrentes fechadas, então me desculpe, tudo bem, esse foi o + +0:30:55.530,0:30:59.730 +cara ok esse é o cara que realmente inventou essas coisas na verdade ele e seus + +0:30:59.730,0:31:07.620 +alunos de volta alguns em 1997 e estávamos bebendo aqui juntos, tudo bem, então + +0:31:07.620,0:31:14.010 +essa é a questão de uma rede neural recorrente e no canto superior esquerdo estão + +0:31:14.010,0:31:18.000 +você verá no diagrama, então eu apenas faço uma versão muito compacta disso + +0:31:18.000,0:31:23.310 +rede neural recorrente aqui será a coleção de equações que + +0:31:23.310,0:31:27.840 +são expressos em uma memória de longo prazo, eles parecem um pouco densos, então eu + +0:31:27.840,0:31:32.970 +apenas desenhe para você aqui ok, vamos realmente ver como essas coisas + +0:31:32.970,0:31:36.320 +funciona então eu vou desenhar um interativo + +0:31:36.320,0:31:40.500 +animação aqui para que você tenha seu portão de entrada aqui, que será um afim + +0:31:40.500,0:31:43.380 +transformação para que todos sejam recorrentes A rede escreve o mesmo + +0:31:43.380,0:31:49.920 +equação que eu mostro aqui para que essa transformação de entrada esteja multiplicando meu C + +0:31:49.920,0:31:55.440 +til que é o meu portão candidato aqui eu tenho um portão não se esqueça que é + +0:31:55.440,0:32:01.920 +multiplicando meu valor anterior da minha memória celular e então meu estilista Poppa talvez + +0:32:01.920,0:32:08.100 +não se esqueça da entrada anterior mais ii vou mostrar agora como funciona então eu + +0:32:08.100,0:32:12.600 +tenho minhas representações ocultas finais para serem elementos de multiplicação + +0:32:12.600,0:32:17.850 +multiplicação entre meu portão de saída e meu você sabe o que quer que seja hiperbólico + +0:32:17.850,0:32:22.740 +versão tangente da célula de tal forma que as coisas são limitadas e então eu tenho + +0:32:22.740,0:32:26.880 +finalmente meu til C, que é meu portão candidato, é simplesmente + +0:32:26.880,0:32:31.110 +Anette certo então você tem uma rede recorrente uma que modula a saída + +0:32:31.110,0:32:35.730 +um que modula este é o portão não esqueça e este é o portão de entrada + +0:32:35.730,0:32:40.050 +então toda essa interação entre a memória e os portões é um multiplicativo + +0:32:40.050,0:32:44.490 +interação e isso esqueça a entrada e não esqueça que a entrada e a saída são + +0:32:44.490,0:32:48.780 +todos os sigmóides e, portanto, eles vão de 0 a 1 para que eu possa multiplicar por um + +0:32:48.780,0:32:53.340 +0 você está de boca fechada ou pode multiplicar por 1 se estiver de boca aberta né + +0:32:53.340,0:33:00.120 +se você pensa em ter nosso volume linear interno que está abaixo + +0:33:00.120,0:33:06.120 +menos 5 ou acima mais 5 ok, de modo que você usa o portão no + +0:33:06.120,0:33:11.940 +área saturada ou 0 ou 1 certo você conhece o sigmóide então vamos ver como essas coisas + +0:33:11.940,0:33:16.260 +funciona esta é a saída vamos desligar o + +0:33:16.260,0:33:20.450 +output como faço para desligar a saída eu simplesmente coloco um 0 + +0:33:20.450,0:33:26.310 +dentro então digamos que eu tenha uma representação interna roxa veja eu coloquei um 0 + +0:33:26.310,0:33:29.730 +lá no portão de saída a saída vai estar multiplicando um 0 com + +0:33:29.730,0:33:36.300 +algo que você recebe 0 ok então vamos dizer que eu tenho um verde eu tenho um então eu + +0:33:36.300,0:33:40.830 +multiplique um com o roxo eu fico roxo e então finalmente eu recebo o mesmo + +0:33:40.830,0:33:46.170 +valor da mesma forma eu posso controlar a memória e posso, por exemplo, configurá-lo neste + +0:33:46.170,0:33:51.240 +caso eu vou ser eu tenho minha memória interna ver isso é roxo e então eu + +0:33:51.240,0:33:57.450 +tenho aqui meu cara anterior que vai ser azul eu acho que tenho um zero aqui e + +0:33:57.450,0:34:01.500 +então a multiplicação me dá um zero aí eu tenho aqui um zero então + +0:34:01.500,0:34:05.190 +a multiplicação vai dar um zero em cerca de dois zeros e eu recebo um zero + +0:34:05.190,0:34:09.690 +dentro da memória, então eu apenas apago a memória e você obtém o zero lá + +0:34:09.690,0:34:15.210 +caso contrário eu posso manter a memória eu ainda faço a coisa interna eu fiz uma nova + +0:34:15.210,0:34:19.919 +mas guardo uma maravilha tal que a multiplicação fica azul o sol fica + +0:34:19.919,0:34:25.649 +azul e então eu continuo enviando minha flor finalmente eu posso escrever de tal forma que eu + +0:34:25.649,0:34:31.110 +pode obter um 1 no portão de entrada a multiplicação fica roxa então o I + +0:34:31.110,0:34:35.010 +defina um zero no não esqueça de tal forma que o + +0:34:35.010,0:34:40.679 +nós esquecemos e então a multiplicação me dá zero eu alguns eu fico roxo e então + +0:34:40.679,0:34:45.780 +Eu recebo a saída roxa final, então aqui nós controlamos como enviar como escrever + +0:34:45.780,0:34:50.850 +na memória como redefinir a memória e como produzir algo bem, então temos + +0:34:50.850,0:35:04.770 +todas as operações diferentes, isso parece um computador - e sim, é + +0:35:04.770,0:35:08.700 +assumido neste caso para mostrar como a lógica funciona como nós somos + +0:35:08.700,0:35:14.250 +ter um valor dentro do sigmóide foi ou abaixo de menos 5 ou está acima + +0:35:14.250,0:35:27.780 +mais 5 tal que estamos trabalhando como switch 0 1 switch ok a rede pode + +0:35:27.780,0:35:32.790 +optar por usar este tipo de operação para mim faz sentido acredito que este é o + +0:35:32.790,0:35:37.110 +a lógica por trás de como esta rede foi montada, a rede pode decidir + +0:35:37.110,0:35:42.690 +para fazer o que quiser, geralmente eles fazem o que querem, mas isso parece + +0:35:42.690,0:35:46.800 +eles podem trabalhar pelo menos se eles tiveram que saturar os portões parece que as coisas + +0:35:46.800,0:35:51.930 +pode funcionar muito bem, então nos 15 minutos restantes do tipo eu estarei + +0:35:51.930,0:35:56.880 +mostrando dois cadernos eu meio que fui um pouco mais rápido porque novamente lá + +0:35:56.880,0:36:04.220 +é muito mais para ser visto aqui nos notebooks então sim + +0:36:10.140,0:36:17.440 +então este é o peso real, o gradiente real que você se importa aqui será o + +0:36:17.440,0:36:21.970 +gradiente em relação ao C anterior certo, o que você se importa será + +0:36:21.970,0:36:25.000 +basicamente a derivada parcial da corrente vista em relação à anterior + +0:36:25.000,0:36:30.160 +C é tal que você se você tem a inicial C original aqui e você tem + +0:36:30.160,0:36:35.140 +vários C ao longo do tempo você quer mudar algo no C original você ainda + +0:36:35.140,0:36:39.130 +tem o gradiente descendo até o primeiro C que desce + +0:36:39.130,0:36:43.740 +para obter gradientes através dessa matriz Wc aqui, então se você quiser mudar + +0:36:46.660,0:36:52.089 +esses pesos aqui você apenas passa pela cadeia de multiplicações que são + +0:36:52.089,0:36:56.890 +não envolvendo nenhuma multiplicação de matrizes como tal que você quando você obtém o + +0:36:56.890,0:37:00.490 +gradiente ainda é multiplicado por um o tempo todo e se reduz a + +0:37:00.490,0:37:05.760 +tudo o que queremos fazer ok eu respondi sua pergunta + +0:37:09.150,0:37:16.660 +então as matrizes vão mudar a amplitude do seu gradiente, então se + +0:37:16.660,0:37:22.000 +você tem como esses maiores autovalores sendo que você conhece 0,0001 toda vez que você + +0:37:22.000,0:37:26.079 +multiplique, você obtém a norma desse vetor sendo morto, então você tem como um + +0:37:26.079,0:37:31.569 +decaimento exponencial neste caso se meu portão de esquecimento for realmente sempre igual a + +0:37:31.569,0:37:37.510 +1 então você obtém c = ct. Qual é a parcial + +0:37:37.510,0:37:43.299 +derivada de c[t]/c[t-1]? + +0:37:43.299,0:37:48.579 +1 certo então as partes do parente que é o + +0:37:48.579,0:37:52.390 +coisa que você realmente multiplica toda vez que haverá 1, então a saída + +0:37:52.390,0:37:57.609 +gradientes de saída de gradiente podem ser gradientes de entrada, sim, eu vou pavilhões + +0:37:57.609,0:38:01.510 +será implícito porque aplicaria o gradiente de saída pela derivada de + +0:38:01.510,0:38:05.599 +este módulo certo se este módulo é e1 então a coisa que é + +0:38:05.599,0:38:14.660 +aqui continua essa é a lógica por trás disso agora isso é só para desenhar + +0:38:14.660,0:38:24.710 +propósitos, eu assumi que é como um interruptor, tudo bem, para que eu possa fazer as coisas que você + +0:38:24.710,0:38:29.089 +sei que você tem um interruptor ligado e desligado para mostrar como deveria estar funcionando, talvez + +0:38:29.089,0:38:46.579 +não funciona assim, mas ainda funciona, pode funcionar dessa maneira, sim, então + +0:38:46.579,0:38:50.089 +essa é a implementação da pergunta profissional será simplesmente você apenas pad + +0:38:50.089,0:38:55.069 +todos os outros sincronizam quando vê com zeros antes da sequência, então se você tiver + +0:38:55.069,0:38:59.920 +várias várias sequências sim várias sequências de comprimento diferente + +0:38:59.920,0:39:03.619 +você acabou de colocá-los todos alinhados à direita + +0:39:03.619,0:39:08.960 +e então você coloca alguns zeros aqui ok tal que você sempre tem no último + +0:39:08.960,0:39:14.599 +coluna o elemento mais recente se você colocar dois zeros aqui vai ser uma bagunça certo + +0:39:14.599,0:39:17.299 +no código se você colocar os zeros no começo você simplesmente para de fazer + +0:39:17.299,0:39:21.319 +propagação de volta quando você acertar o último símbolo certo, então você começa a partir daqui + +0:39:21.319,0:39:25.460 +volte aqui para ir em frente, então você volta prop e pare sempre que você + +0:39:25.460,0:39:29.599 +realmente chegar ao final de sua seqüência se você pad do outro lado você obtém um + +0:39:29.599,0:39:34.730 +monte de queda lá nos próximos dez minutos, então você vai ser visto dois + +0:39:34.730,0:39:45.049 +cadernos se você não tiver outras perguntas ok uau você está tão quieto ok + +0:39:45.049,0:39:49.970 +então vamos agora para a classificação de sequências bem, então neste caso + +0:39:49.970,0:39:54.589 +Eu vou ser eu realmente falo alto o objetivo é classificar um + +0:39:54.589,0:40:00.259 +sequência de elementos elementos de sequência e alvos são representados localmente + +0:40:00.259,0:40:05.660 +vetores de entrada com apenas um bit diferente de zero, então é um hot codificando a sequência + +0:40:05.660,0:40:10.770 +começa com um B para começar e terminar com um E e, caso contrário, consiste em um + +0:40:10.770,0:40:16.370 +símbolos escolhidos aleatoriamente de um conjunto {a, b, c, d} que são algum tipo de ruído + +0:40:16.370,0:40:22.380 +espere para dois elementos na posição t1 e t2 esta posição pode ser ou X + +0:40:22.380,0:40:29.460 +ou Y para o nível de dificuldade difícil que você tem, por exemplo, que a sequência + +0:40:29.460,0:40:35.220 +comprimento comprimento é escolhido aleatoriamente entre 100 e 110 10 t1 é escolhido aleatoriamente + +0:40:35.220,0:40:40.530 +entre 10 e 20 Tinto é escolhido aleatoriamente entre 50 e 60 há quatro + +0:40:40.530,0:40:47.010 +classes de sequências Q, R, S e U que depende da ordem temporal de x e y então se + +0:40:47.010,0:40:53.520 +você tem X,X você pode estar recebendo um Q. X,Y você ganha um R. Y,X você ganha um S + +0:40:53.520,0:40:57.750 +e Y,Y obtém U. Então, vamos fazer uma classificação de sequência com base em + +0:40:57.750,0:41:03.720 +o X e y ou o que quer que importe para esses tipos de gatilhos, ok + +0:41:03.720,0:41:08.370 +e no meio no meio você pode ter a,b,c,d em posições aleatórias como você + +0:41:08.370,0:41:12.810 +sei gerado aleatoriamente está claro até agora, então lançamos uma classificação de + +0:41:12.810,0:41:23.180 +seqüências onde você pode ter esses X,XX,YY,X ou Y,Y. Então neste caso + +0:41:23.210,0:41:29.460 +Estou mostrando primeiro a primeira entrada para que o tipo de retorno seja uma tupla de sequência + +0:41:29.460,0:41:36.780 +de dois que vai ser qual é a saída deste gerador de exemplo e assim + +0:41:36.780,0:41:43.050 +vamos ver o que é isso aqui então esses são meus dados que eu vou ser + +0:41:43.050,0:41:48.030 +alimentando a rede, então eu tenho 1, 2, 3, 4, 5, 6, 7, 8 + +0:41:48.030,0:41:54.180 +símbolos diferentes aqui em uma linha cada vez que há oito nós + +0:41:54.180,0:42:02.970 +têm X e Y e a, b, c e d início e fim. Então nós temos um quente fora de você + +0:42:02.970,0:42:08.400 +sei oito caracteres e então eu tenho uma sequência de linhas que são minha sequência + +0:42:08.400,0:42:12.980 +de símbolos ok neste caso você pode ver aqui eu tenho um começo com todos os zeros + +0:42:12.980,0:42:19.260 +por que todos os zeros estão corretos, então, neste caso, a sequência foi menor que + +0:42:19.260,0:42:21.329 +a esperar a sequência máxima na cama + +0:42:21.329,0:42:29.279 +e então a primeira primeira sequência tem um item zero extra no início nelas + +0:42:29.279,0:42:34.859 +você vai ter como neste caso o segundo item é dos dois um pólo a pólo + +0:42:34.859,0:42:41.160 +é a melhor classe correspondente, por exemplo, tenho um tamanho de lote de 32 e + +0:42:41.160,0:42:51.930 +então eu vou ter um tamanho de saída de 4. Por que 4 ? Q, R, S e U. + +0:42:51.930,0:42:57.450 +então eu tenho 4 um vetor alvo de 4 dimensões e tenho uma sequência de 8 + +0:42:57.450,0:43:04.499 +vetores dimensionais como entrada ok, então vamos ver como essa sequência se parece + +0:43:04.499,0:43:12.779 +neste caso será BbXcXcbE. Então X,X vamos ver que XXXX é Q + +0:43:12.779,0:43:18.569 +certo, então temos nossa sequência Q e é por isso que o alvo final é um Q o 1 + +0:43:18.569,0:43:25.019 +0 0 0 e então você verá BBXC então o segundo item e o penúltimo + +0:43:25.019,0:43:30.390 +vai ser B minúsculo B você pode ver aqui o segundo item e o penúltimo + +0:43:30.390,0:43:36.390 +o item vai ficar bem, então vamos agora criar uma rede recorrente + +0:43:36.390,0:43:41.249 +de uma maneira muito rápida, então aqui posso simplesmente dizer que minha rede recorrente será + +0:43:41.249,0:43:47.369 +tocha e um RNN e vou usar uma rede de leitura realmente não linear + +0:43:47.369,0:43:52.709 +e então eu tenho minha camada linear final no outro caso eu vou usar um led + +0:43:52.709,0:43:57.119 +STM e então eu vou ter uma camada interna final, então eu apenas executo esses caras + +0:43:57.119,0:44:07.920 +Eu tenho meu loop de treinamento e vou treinar para 10 livros, então no treinamento + +0:44:07.920,0:44:13.259 +grupo você pode estar sempre procurando por esses cinco passos diferentes, o primeiro passo é + +0:44:13.259,0:44:18.900 +vamos obter os dados dentro do modelo correto, então esse é o passo número um, o que é + +0:44:18.900,0:44:30.669 +passo número dois há cinco passos que lembramos olá + +0:44:30.669,0:44:35.089 +você sente que alimenta a rede se alimenta a rede com alguns dados, então + +0:44:35.089,0:44:41.539 +o que você faz você calcula a perda ok, então temos o passo de cálculo para calcular o + +0:44:41.539,0:44:52.549 +perda fantástica número três é zero o dinheiro certo então o número quatro que é + +0:44:52.549,0:45:09.699 +computando o off sim cachorro perdido para trás perdido não para trás não computar o + +0:45:09.699,0:45:16.449 +derivada parcial da perda em relação aos parâmetros da rede sim + +0:45:16.449,0:45:27.380 +aqui para trás, finalmente, número cinco, que é um passo na direção oposta do + +0:45:27.380,0:45:31.819 +gradiente tudo bem esses são os cinco passos que você sempre quer ver em qualquer + +0:45:31.819,0:45:37.909 +plano de treinamento se alguém estiver faltando, então você está [ __ ] bem, então tentamos agora + +0:45:37.909,0:45:42.469 +o RNN e o LSTM e você obtém algo parecido com isso + +0:45:42.469,0:45:55.929 +então nosso NN vai até 50% em precisão e então o LSTM ficou 100% ok oh ok + +0:45:56.439,0:46:06.019 +em primeiro lugar, quantos pesos este LSTM tem em comparação com o RNN quatro + +0:46:06.019,0:46:11.059 +vezes mais pesos certo, então não é uma comparação justa, eu diria porque LSTM + +0:46:11.059,0:46:16.819 +é simplesmente para rnns combinados de alguma forma certo, então este é um neural de duas camadas + +0:46:16.819,0:46:20.659 +rede enquanto o outro está em uma camada certa sempre ambos sempre como se tivesse + +0:46:20.659,0:46:25.009 +uma camada oculta eles são um fim se Alice TM podemos pensar em ter duas + +0:46:25.009,0:46:33.199 +escondido então novamente uma camada duas camadas bem uma escondida para levar em um conjunto de + +0:46:33.199,0:46:37.610 +parâmetros quatro conjuntos dos mesmos números como ok não justo ok de qualquer maneira + +0:46:37.610,0:46:43.610 +vamos com cem iterações ok, então agora eu vou com 100 iterações e eu + +0:46:43.610,0:46:49.490 +mostrar como funcionam ou não e também quando estou apenas clicando em coisas como + +0:46:49.490,0:46:56.000 +que temos tempo para fazer as coisas ok agora meu computador vai ser + +0:46:56.000,0:47:02.990 +reclamando tudo bem então novamente quais são os cinco tipos de operações como cinco + +0:47:02.990,0:47:06.860 +ok agora já está feito desculpe eu ia fazer tudo bem então é isso + +0:47:06.860,0:47:16.280 +o RNN certo RNN e finalmente deu a 100% ok então ferro e só + +0:47:16.280,0:47:20.030 +deixe mais tempo como um pouco mais de treinamento mais longo realmente funciona o outro + +0:47:20.030,0:47:26.060 +um ok e aqui você pode ver que temos 100% em vinte e oito dólares ok o + +0:47:26.060,0:47:30.650 +outro caso, obtivemos 2.100% em aproximadamente o dobro do tempo + +0:47:30.650,0:47:35.690 +duas vezes mais de cada vez ok, então vamos primeiro ver como eles se comportam aqui, então eu + +0:47:35.690,0:47:42.200 +temos essa sequência BcYdYdaE que é uma sequência U e então perguntamos a rede + +0:47:42.200,0:47:46.760 +e ele realmente quis dizer como rótulos como você está bem, então abaixo estamos + +0:47:46.760,0:47:51.140 +veremos algo muito fofo, então neste caso estávamos usando sequências + +0:47:51.140,0:47:56.870 +que são muito, muito, muito pequenos, então até o RNN é capaz de treinar + +0:47:56.870,0:48:02.390 +essas pequenas sequências, então qual é o ponto de usar um LSTM bem, podemos primeiro + +0:48:02.390,0:48:07.430 +de tudo aumentar a dificuldade da parte do treinamento e vamos ver isso + +0:48:07.430,0:48:13.280 +o RNN pode estar falhando miseravelmente enquanto o LSTM continua trabalhando neste + +0:48:13.280,0:48:19.790 +parte de visualização abaixo ok eu treino uma rede agora Alice e LSTM agora com o + +0:48:19.790,0:48:26.000 +nível moderado que tem oitenta símbolos em vez de oito ou dez dez símbolos, então + +0:48:26.000,0:48:31.430 +você pode ver aqui como esse modelo realmente conseguiu ter sucesso no final, embora + +0:48:31.430,0:48:38.870 +há um pico muito grande e agora vou desenhar o valor do + +0:48:38.870,0:48:43.970 +estado da célula ao longo do tempo ok, então eu vou entrar em nossa sequência de oitenta + +0:48:43.970,0:48:49.090 +símbolos e eu vou mostrar a você qual é o valor do estado oculto + +0:48:49.090,0:48:53.330 +estado oculto, então, neste caso, eu vou mostrar a você + +0:48:53.330,0:48:56.910 +[Música] escondido espera + +0:48:56.910,0:49:01.140 +sim, vou mostrar que vou enviar minha entrada através de uma tangente hiperbólica + +0:49:01.140,0:49:06.029 +de tal forma que se você estiver abaixo de menos 2,5 eu vou mapear para menos 1 se você estiver + +0:49:06.029,0:49:12.329 +acima de 2,5 você é mapeado para mais 1 mais ou menos e então vamos ver como essas coisas + +0:49:12.329,0:49:18.029 +parece que, neste caso, você pode ver que essa camada oculta específica foi selecionada + +0:49:18.029,0:49:27.720 +no X aqui e então ficou vermelho até você acertar o outro X então isso + +0:49:27.720,0:49:33.710 +está visualizando o estado interno do LSD e assim você pode ver isso em + +0:49:33.710,0:49:39.599 +unidade porque neste caso eu uso representação oculta como dimensão oculta de + +0:49:39.599,0:49:47.700 +10 e assim neste caso o 1 2 3 4 5 a quinta unidade oculta da célula + +0:49:47.700,0:49:52.829 +A 5ª célula na verdade é acionada observando o primeiro X e depois vai + +0:49:52.829,0:49:58.410 +quieto depois de ver os outros atos, isso me permite basicamente você saber + +0:49:58.410,0:50:07.440 +cuidar de quero dizer reconhecer se a sequência é U, P, R ou S. Ok, faz sentido ok + +0:50:07.440,0:50:14.519 +ah mais esse notebook que vou mostrar rapidinho que é o 09-echo_data + +0:50:14.519,0:50:22.410 +neste caso eu vou estar no canto sul vou ter um eco de rede em + +0:50:22.410,0:50:27.059 +o que quer que eu esteja dizendo, se eu disser algo, pedi a uma rede para dizer se eu + +0:50:27.059,0:50:30.960 +fala alguma coisa eu pedi pro meu vizinho falar se eu falar alguma coisa eu peço ok Anderson + +0:50:30.960,0:50:42.150 +certo ok então neste caso aqui e eu estarei inserindo esta é a primeira sequência + +0:50:42.150,0:50:50.579 +vai ser 0 1 1 1 1 0 e você terá o mesmo aqui 0 1 1 1 1 0 e eu + +0:50:50.579,0:50:57.259 +tem 1 0 1 1 0 1 etc certo, então, neste caso, se você quiser produzir algo + +0:50:57.259,0:51:00.900 +depois de algum certo isso neste caso é três vezes + +0:51:00.900,0:51:06.809 +passo depois você tem que ter algum tipo de memória de curto prazo onde você tenha em mente + +0:51:06.809,0:51:11.780 +o que eu acabei de dizer onde você tem em mente o que eu acabei de dizer onde você tem em mente + +0:51:11.780,0:51:16.890 +[Música] o que acabei de dizer, sim, está correto, então + +0:51:16.890,0:51:22.099 +você sabe que a pirataria realmente requer algum tipo de memória de trabalho + +0:51:22.099,0:51:27.569 +enquanto o outro o modelo de linguagem que foi levado a dizer + +0:51:27.569,0:51:33.539 +algo que eu ainda não disse direito, então esse foi um tipo diferente de + +0:51:33.539,0:51:38.700 +tarefa que você realmente teve que prever qual é a próxima palavra mais provável no keynote que você + +0:51:38.700,0:51:42.329 +não pode estar sempre certo, mas este você sempre pode estar certo, você sabe + +0:51:42.329,0:51:49.079 +isso é que não há coisas aleatórias de qualquer maneira, então eu tenho meu primeiro lote aqui e depois + +0:51:49.079,0:51:53.549 +a sec a mancha branca que é a mesma coisa semelhante que é deslocada + +0:51:53.549,0:52:01.319 +tempo e então temos que fragmentar essa sequência longa, longa, então antes de eu + +0:52:01.319,0:52:05.250 +estava enviando uma sequência inteira dentro da rede e eu estava aplicando o final + +0:52:05.250,0:52:09.569 +target para ser algo certo, neste caso, eu tive que separar se a sequência for + +0:52:09.569,0:52:13.319 +nessa direção eu tive que dividir minha longa sequência em pequenos pedaços e então você + +0:52:13.319,0:52:18.869 +tem que preencher o primeiro pedaço manter o rastro de qualquer que seja o estado oculto enviar um + +0:52:18.869,0:52:23.549 +novo pedaço onde você alimenta e inicialmente como o estado oculto inicial a saída + +0:52:23.549,0:52:28.319 +deste canto certo então você alimenta este pedaço você tem um estado oculto final então + +0:52:28.319,0:52:33.960 +você alimenta esse pedaço e como você coloca você tem que colocar esses dois como entrada para o + +0:52:33.960,0:52:38.430 +memória interna agora você alimenta o próximo pedaço onde você coloca este como + +0:52:38.430,0:52:44.670 +entrada quanto ao estado interno e você vamos comparar aqui RNN + +0:52:44.670,0:52:57.059 +com o analista TMS eu acho que no final aqui você pode ver que tudo bem nós conseguimos + +0:52:57.059,0:53:02.789 +na verdade, somos uma precisão n/a que vai de 100 a 100 por cento, então se você estiver + +0:53:02.789,0:53:08.220 +começando agora a mexer com o tamanho do pedaço de memória com um intervalo de memória + +0:53:08.220,0:53:11.619 +você pode ser visto com o LSTM você pode manter esta memória + +0:53:11.619,0:53:16.399 +por um longo tempo, desde que você tenha capacidade suficiente do RNN depois de atingir + +0:53:16.399,0:53:22.880 +algum tipo de comprimento você começa a esquecer o que aconteceu no passado e foi + +0:53:22.880,0:53:29.809 +praticamente tudo por hoje então fique aquecido lave as mãos e eu vou te ver + +0:53:29.809,0:53:34.929 +semana que vem tchau \ No newline at end of file