< Return to Video

RDAG CAP02 2025 VA03 CNN CONCEITOS E PRINCIPIOS

  • 0:08 - 0:10
    Como uma ceninha ele funciona.
  • 0:10 - 0:13
    Antes de mais nada, é importante entender
    como que a entrada para esse tipo de rede
  • 0:13 - 0:16
    é formada,
    que é justamente a composição de imagem.
  • 0:17 - 0:19
    Aqui nós temos uma representação
    de uma imagem
  • 0:19 - 0:23
    clássica, ou nós temos aqui uma diferença
    entre linhas e colunas
  • 0:23 - 0:26
    na matriz de linhas e colunas
    em três dimensões.
  • 0:26 - 0:29
    Cada dimensão
    é um canal de cor dessa imagem.
  • 0:29 - 0:33
    Geralmente é vermelho, verde e azul.
  • 0:33 - 0:36
    Isso compõe a função RGB de uma imagem.
  • 0:36 - 0:39
    Basicamente,
    nós temos pixels que vão de zero
  • 0:39 - 0:42
    até dois
    cinco cinco em cada célula dessa imagem
  • 0:42 - 0:47
    em cada um dos canais, e a soma deles
    resulta na imagem final.
  • 0:47 - 0:48
    A cor final que nós vemos na tela.
  • 0:48 - 0:51
    Por exemplo, nessa representação
    nós temos o número oito feito à mão.
  • 0:52 - 0:56
    Então é uma imagem esticadinha
    sobre esse número oito e à mão.
  • 0:56 - 0:59
    Nós temos aqui a representação
    pixel pixel dessa imagem.
  • 1:00 - 1:04
    O zero é a cor preta e O255
    é a cor branca.
  • 1:04 - 1:08
    Existe uma série de variações
    desses valores, que são no caso,
  • 1:08 - 1:09
    uma escala de cinza.
  • 1:09 - 1:14
    E aqui na terceira parte
    nós temos a matriz de pixels,
  • 1:14 - 1:19
    onde temos o valor de cada pixel
    em cada posição, até possível entender
  • 1:19 - 1:22
    como está a localização
    do oito nessa imagem.
  • 1:23 - 1:26
    Então, para a
    máquina poder aprender essa representação,
  • 1:26 - 1:30
    ela tem que aprender a mistura de borda
    diferença desses valores
  • 1:31 - 1:34
    para uma aresta
    e para uma bolinha aqui de cima.
  • 1:34 - 1:39
    Uma bolinha aqui de baixo que está
    compondo a técnica visual do número oito.
  • 1:39 - 1:42
    Então, numa CNN,
    a camada de entrada se conecta
  • 1:42 - 1:45
    diretamente a cada pixel das imagens.
  • 1:45 - 1:48
    Agora, como ela extrai
    características dessas imagens?
  • 1:49 - 1:53
    A operação principal que dá nome
    a CNN e a convolução a convolução,
  • 1:53 - 1:58
    operação matemática que representa a soma
    de produto de dois duas funções.
  • 1:58 - 2:03
    Aqui no caso, uma função vai ser expressa
    pelo dado pela imagem, por exemplo.
  • 2:03 - 2:07
    E outra função é uma matriz de pesos
    que tá representando a important
  • 2:07 - 2:11
    de cada parte da imagem
    na representação daquele conteúdo.
  • 2:11 - 2:13
    Vamos entender isso pela própria imagem.
  • 2:13 - 2:17
    Então aqui nós temos uma representação de
    uma arquitetura profunda baseada em CNN.
  • 2:18 - 2:20
    Temos a camada de entrada
    e a camada de saída,
  • 2:20 - 2:23
    essencialmente a parte da CNN de fato,
  • 2:23 - 2:27
    e da camada de entrada
    até quase antes da saída,
  • 2:27 - 2:30
    porque é uma parte da rede utilizada
    para a extração de filtros,
  • 2:31 - 2:34
    que são operação de convolução,
    sendo passada
  • 2:34 - 2:37
    por cada uma das partes dessa imagem.
  • 2:38 - 2:42
    Essa convolução gera uma
    um input para a próxima camada que faz uma
  • 2:42 - 2:46
    nova convolução sobre a camada anterior
    e assim sucessivamente.
  • 2:47 - 2:50
    O que eu está aprendendo
    são representações diretamente da imagem,
  • 2:50 - 2:53
    como por exemplo arestas, cantos
  • 2:53 - 2:57
    e depois coisa mais alto nível,
    como variação de cor,
  • 2:58 - 3:01
    variação de textura ou então
    combinação de partes que formam um todo.
  • 3:02 - 3:05
    Então o olhinho ou focinho
    que representa a cara de um cachorro,
  • 3:06 - 3:10
    um ponteiro, o número
    que representa a dimensão de um relógio.
  • 3:11 - 3:13
    Quando nós chegamos
    nas últimas camadas com os sinais,
  • 3:13 - 3:17
    nós vamos ter um vetor
    com alguma dimensão.
  • 3:17 - 3:20
    Então, por exemplo, 4096
    ou outro número relevante,
  • 3:20 - 3:23
    isso alimenta
    uma rede neural artificial clássica
  • 3:23 - 3:27
    que aprende a distinguir
    o que significa esse dado, ou seja,
  • 3:27 - 3:32
    esse vetor de 4000 dimensões representa
    que tipo de imagem pode ser um cachorro.
  • 3:33 - 3:37
    Essa outra, esse outro vetor
    que representa uma outra imagem,
  • 3:37 - 3:40
    significa o que é um gato, uma flor.
  • 3:40 - 3:43
    E assim vai até a máquina
    conseguir aprender
  • 3:43 - 3:46
    como distinguir uma imagem da outra.
  • 3:46 - 3:48
    Se o cerne da questão é uma convolução,
    é muito importante
  • 3:48 - 3:51
    nós entendermos como a convolução
    funciona.
  • 3:52 - 3:52
    Nós podemos entender
  • 3:52 - 3:56
    uma convolução como uma janela deslizante
    que está passando pela imagem de entrada.
  • 3:57 - 4:00
    A primeira convolução é fácil
    de ser entendida porque está pegando uma
  • 4:00 - 4:04
    janela de uma dimensão específica
    e deslizando pela imagem como um todo
  • 4:04 - 4:08
    e saindo informações parciais
    de cada parte dessa imagem.
  • 4:09 - 4:12
    Essa imagem resultante,
    que não é bem uma imagem,
  • 4:12 - 4:16
    mas algo tridimensional, que representa
    os pixels não mastigados, serve de entrada
  • 4:17 - 4:20
    para uma outra camada com o sinal
    que estamos numa outra janela deslizante.
  • 4:21 - 4:23
    Cada janela dessa
    pode ser um peso diferente
  • 4:23 - 4:24
    que representa a importância
  • 4:24 - 4:28
    daquela região da imagem para caracterizar
    o seu elemento principal,
  • 4:28 - 4:31
    ou seja, a principal classe presente
    naquela imagem.
  • 4:32 - 4:35
    Vamos entender o processo
    pela forma diagrama.
  • 4:35 - 4:40
    Para simplificar, imagine uma imagem bem
    pequenininha aqui de quatro por cinco,
  • 4:40 - 4:44
    com alguns valores aqui, zeros
    e uns que indicam um pixel qualquer.
  • 4:44 - 4:49
    E nós temos aqui uma matriz menor
    que apresenta um peso a ser aprendido,
  • 4:49 - 4:52
    que representa uma janela dois por dois.
  • 4:53 - 4:55
    Então essa janela vai deslizar
    pela imagem.
  • 4:56 - 4:59
    Quando nós passamos pela primeira
    região, nós vamos multiplicar
  • 5:00 - 5:01
    os pixels dessa imagem
  • 5:01 - 5:04
    pelo peso dessa matriz
    que representa esse valor.
  • 5:04 - 5:07
    Três Quando eu faço um passinho por lado,
  • 5:08 - 5:12
    essa multiplicação dessa parte do pixel
    pelo peso da matriz
  • 5:13 - 5:17
    representa um outro valor condensado
    que é o três e assim sucessivamente.
  • 5:17 - 5:23
    Nós dando pulinhos nessa janela ou para
    a direita ou para baixo em duas dimensões.
  • 5:23 - 5:26
    Quando nós percorremos toda a imagem,
    nós vamos ter
  • 5:26 - 5:29
    uma imagem resultante
    que tem essa característica.
  • 5:30 - 5:32
    Se nós queremos plotar
    a imagem de entrada,
  • 5:32 - 5:34
    vamos conseguir entender
    o seu significado.
  • 5:34 - 5:35
    A imagem de saída,
  • 5:35 - 5:38
    Essa convolução é algo que é difícil
    de ser interpretado pelo ser humano,
  • 5:38 - 5:42
    mas a máquina consegue entender
    que tem uma informação relevante para ela.
  • 5:42 - 5:43
    Ou seja, alguns.
  • 5:43 - 5:47
    Os pixels foram mastigados para condensar
    informação importante
  • 5:47 - 5:51
    para caracterizar a qual classe
    aquela imagem de entrada pertence.
  • 5:52 - 5:54
    De forma intuitiva,
    você pode pensar o seguinte
  • 5:54 - 5:58
    se a minha janela for muito pequena
    e ou se uma imagem for muito grande,
  • 5:59 - 6:03
    esse filtro convencional
    pode gerar uma outra matriz muito grande.
  • 6:03 - 6:04
    Ou seja,
  • 6:04 - 6:07
    será que isso pode não ser eficiente
    para representar aquele conteúdo?
  • 6:08 - 6:10
    Muito
    provavelmente não será tão eficiente.
  • 6:10 - 6:13
    Portanto, outra operação tão importante
    quanto a convolução é o pulling.
  • 6:14 - 6:19
    o porém representa uma sumarização
    de uma parte dessa imagem resultante,
  • 6:19 - 6:20
    digamos assim.
  • 6:20 - 6:23
    Então, essa região representada
    por esse quadrado aqui em vermelho,
  • 6:23 - 6:26
    pode ser simbolizada pelo pixel
    mais importante que essa região.
  • 6:27 - 6:29
    Por exemplo, o seu maior valor em três.
  • 6:29 - 6:34
    Quando eu pego essa outra região aqui,
    o maior valor desse pixel é um
  • 6:35 - 6:36
    dessa outra região.
  • 6:36 - 6:39
    O maior valor é o dois
    e dessa outra região maior.
  • 6:39 - 6:41
    O valor presente é um.
  • 6:41 - 6:46
    Portanto, aquela imagem que entrou de três
    por quatro ficou reduzida.
  • 6:46 - 6:49
    É uma imagem, ou melhor,
    uma matriz de dois por dois.
  • 6:50 - 6:53
    Esse é apenas um dos tipos de pura
    que existem que é o Max.
  • 6:53 - 6:57
    Porém, nós podemos trabalhar também
    com Every de pulling, ou seja,
  • 6:57 - 6:59
    aqueles picos daquela região.
  • 6:59 - 7:02
    Nós fazemos a média deles
    e levamos essa média adiante.
  • 7:03 - 7:06
    Agora que a primeira convolução
    e o pulo foi aplicado,
  • 7:06 - 7:10
    essa matriz resultante serve de entrada
    para a próxima operação de convolução
  • 7:10 - 7:12
    e depois um pulo e depois outro.
  • 7:12 - 7:13
    Convolução e depois um pulo.
  • 7:13 - 7:17
    Ou então outros arranjos, como diversas
    convolução sucessivas.
  • 7:17 - 7:19
    Terminamos em uma operação de público.
  • 7:19 - 7:22
    Ou seja, tem uma regra para construir
    essa arquitetura própria de CNN
  • 7:23 - 7:26
    Sim não a regra
    para otimizar conversões e pulling,
  • 7:26 - 7:28
    mas o encadeamento entre
  • 7:28 - 7:31
    elas pode ser uma definição que você
    vai montar na sua própria criatura.
  • 7:31 - 7:34
    no entanto, existem outras configurações
    que podem ser feitas
  • 7:34 - 7:38
    para tornar esse aprendizado mais robusto,
    ou se ele tentar aprender
  • 7:38 - 7:42
    mais nuances dessas imagens,
    como por exemplo o pede e também o string.
  • 7:43 - 7:44
    O pede está justamente
  • 7:44 - 7:49
    relacionado a evitar a perda de informação
    que está na borda da imagem com você.
  • 7:49 - 7:52
    Essa imagem original está aqui
    nessa região em azul.
  • 7:52 - 7:56
    É naturalmente visível
    que quanto mais a gente está deslizando
  • 7:56 - 7:57
    pela imagem,
  • 7:57 - 8:01
    a informação do centro tende a ser
    mais valorizada para essa ação de filtros,
  • 8:01 - 8:04
    sendo que a informação que está na borda
    tende a ser ignorada.
  • 8:05 - 8:09
    Quando nós fazemos ou pede, estamos
    colocando como se fossem pixels falsos
  • 8:10 - 8:13
    em volta da imagem para simular uma imagem
    um pouco maior.
  • 8:13 - 8:16
    Assim, a borda que é perdida
    vai ser uma borda
  • 8:16 - 8:19
    que de fato seria irrelevante.
  • 8:20 - 8:22
    Outra estratégia interessante
  • 8:22 - 8:26
    é o sprite, que diz justamente
    o tamanho do passo da janela deslizante.
  • 8:26 - 8:29
    Pela imagem podemos pensar menor ou maior.
  • 8:30 - 8:34
    E essas são apenas duas configurações
    possíveis na montagem sua arquitetura.
  • 8:34 - 8:35
    Fora isso,
  • 8:35 - 8:39
    você pode pensar quantas convulsões,
    quantos pulinhos, qual, além deles também
  • 8:40 - 8:44
    e outros até que ajudam a deixar a rede
    mais especializada, mais rápida
  • 8:44 - 8:48
    ou até mais específica a um tipo de dado
    que você queira construir.
  • 8:49 - 8:51
    Com isso, nós podemos ter outros tipos
  • 8:51 - 8:54
    de redes neurais profundas baseadas em CNN
  • 8:54 - 8:56
    a partir de uma rede tradicional,
    digamos assim.
  • 8:56 - 8:59
    Nós podemos ter imagens
    de outras características principais,
  • 9:00 - 9:02
    como por exemplo,
    as que estão na imagem a seguir.
  • 9:02 - 9:05
    Partindo de uma rede tradicional,
    digamos assim, podemos pensar
  • 9:05 - 9:09
    numa rede mais ampla,
    que possui uma janela de entrada maior,
  • 9:09 - 9:13
    uma rede mais profunda,
    que possui mais camadas convencionais
  • 9:13 - 9:18
    e ou de pool e uma rede de maior resolução
    que está preparada para trabalhar
  • 9:18 - 9:22
    com imagens de maior resolução de fato,
    ou seja, imagens maiores.
  • 9:22 - 9:26
    Dadas estas e outras configurações,
    não é de se admirar que existem diversas
  • 9:26 - 9:30
    arquiteturas neurais profundas
    para se trabalhar com scene.
  • 9:30 - 9:34
    Ou seja, diversas propostas de regionais
    baseadas em CNN
  • 9:34 - 9:39
    foram surgindo ao longo do tempo, cada uma
    com suas caraterísticas peculiares.
  • 9:39 - 9:40
    Por exemplo.
  • 9:40 - 9:43
    Se o tamanho da imagem representa
    a quantidade de parâmetros
  • 9:43 - 9:47
    a ser aprendido no treinamento,
    temos redes muito grandes,
  • 9:47 - 9:48
    muito profundas.
  • 9:48 - 9:52
    Eles não tão profundas
    assim, redes que possuem um desempenho
  • 9:52 - 9:55
    muito bom na imagem net
    e outras que exigem
  • 9:55 - 9:59
    uma quantidade muito grande de operações
    serem feitas por segundo.
  • 9:59 - 10:02
    Agora, qual dessa criatura melhor
    se adequa ao seu problema?
  • 10:02 - 10:05
    Depende de uma série de questões,
    como por exemplo
  • 10:05 - 10:08
    qual é o ambiente funcional
    onde você vai treinar?
  • 10:08 - 10:10
    E os aspones?
  • 10:10 - 10:13
    Qual é o conjunto de dados que você vai
    utilizar, se algo mais específico
  • 10:13 - 10:16
    ou geral, ou até mesmo o tamanho de dados
    que você tem para treinar essas redes.
  • 10:17 - 10:20
    Portanto,
    a melhor saída é sempre a experimentação
Title:
RDAG CAP02 2025 VA03 CNN CONCEITOS E PRINCIPIOS
Video Language:
Portuguese, Brazilian
Duration:
10:23

Portuguese, Brazilian subtitles

Incomplete

Revisions Compare revisions