Carregando
0xE0Lição 15 de 18

Visão computacional: como as máquinas enxergam

Represente imagens como grades de números, deslize filtros para detectar bordas e combine convoluções em uma CNN.

22 min Questionário com 6 perguntas 2 exercícios de código
Ao final desta lição, você saberá
  • Descrever uma imagem em tons de cinza como uma matriz de valores de brilho
  • Aplicar um filtro de convolução manualmente
  • Explicar como uma rede convolucional constrói representações de bordas a objetos

Para um computador, uma foto é apenas uma grade de números. Em uma imagem em tons de cinza, cada pixel guarda um valor de brilho entre 0 (preto) e 255 (branco). Uma imagem colorida guarda três grades: vermelho, verde e azul. Uma foto de celular pode ter cerca de 12 milhões de pixels — 36 milhões de números.

Tudo o que a visão computacional faz — reconhecer rostos, ler placas, identificar tumores em exames — começa com esses números.

Experimente

Até 15 XP

Pinte com números

Cada célula representa um pixel; o número indica seu brilho. Escolha um pincel e clique nas células para redesenhar o rosto: acrescente um nariz ou apague o sorriso. Observe a lista Python abaixo da imagem mudar a cada clique: para o computador, aquela lista é a imagem.

Pincel:
Clique nos pixels para pintá-los
image = [
    [0, 0, 255, 255, 255, 255, 0, 0],
    [0, 255, 0, 0, 0, 0, 255, 0],
    [255, 0, 192, 0, 0, 192, 0, 255],
    [255, 0, 0, 0, 0, 0, 0, 255],
    [255, 0, 128, 0, 0, 128, 0, 255],
    [255, 0, 0, 128, 128, 0, 0, 255],
    [0, 255, 0, 0, 0, 0, 255, 0],
    [0, 0, 255, 255, 255, 255, 0, 0],
]

Convolução: deslizando uma pequena janela

Como detectar uma borda em uma grade de números? Uma borda aparece onde o brilho muda de repente, então comparamos cada pixel com seus vizinhos. Um filtro (ou kernel) é uma pequena grade de pesos, muitas vezes 3 × 3. A convolução desliza esse filtro por cada posição da imagem; em cada posição, multiplicamos os pesos pelos pixels correspondentes e somamos:

saıˊda(r,c)=∑i∑jfiltro(i,j)⋅imagem(r+i,c+j)\text{saída}(r, c) = \sum_{i} \sum_{j} \text{filtro}(i, j) \cdot \text{imagem}(r + i, c + j)

É mais um produto escalar — entre o filtro e uma região da imagem. Filtros diferentes detectam padrões diferentes: um filtro de desfoque calcula a média dos vizinhos; um filtro de bordas subtrai um lado do outro. Áreas uniformes resultam em zero, enquanto bordas geram valores maiores.

Experimente

Até 15 XP

Experimente filtros diferentes

Escolha um filtro e clique em qualquer pixel da saída para ver a multiplicação e a soma que produziram aquele valor. Qual filtro destaca apenas os lados esquerdo e direito do quadrado? Qual detecta melhor a linha diagonal?

Entrada (clique em um pixel da saída)
Kernel
Edite qualquer peso para criar seu próprio filtro.
Saída (laranja = negativo)

Saída na linha 6, coluna 6 = soma de (pixel × peso) na janela destacada 3×3 (pixels fora da imagem valem 0):

220×.11 + 220×.11 + 220×.11 + 20×.11 + 20×.11 + 20×.11 + 20×.11 + 20×.11 + 220×.11 = 108.89

convolve.py
1image = [
2    [10, 10, 10, 200, 200],
3    [10, 10, 10, 200, 200],
4    [10, 10, 10, 200, 200],
5]
6kernel = [[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]]   # mudança da esquerda para a direita
7
8row = 0   # uma linha de saída: o canto superior esquerdo do filtro percorre a linha 0
9outputs = []
10for column in range(len(image[0]) - 2):
11    total = 0
12    for i in range(3):
13        for j in range(3):
14            total += kernel[i][j] * image[row + i][column + j]
15    outputs.append(total)
16print(outputs)
Saída
[0, 570, 570]

Redes neurais convolucionais

No exercício, você escolheu filtros criados por pessoas. Uma rede neural convolucional (CNN) aprende os pesos dos filtros com descida do gradiente e descobre quais ajudam na tarefa. Como o mesmo filtro pequeno percorre a imagem toda, são necessários apenas 9 pesos, e não um por pixel (pesos compartilhados). Assim, ele encontra um padrão onde quer que apareça.

Uma CNN combina camadas:

  • Camadas convolucionais aplicam vários filtros aprendidos; cada um produz um mapa de características.
  • Camadas de pooling reduzem cada mapa, por exemplo mantendo o maior valor de cada bloco 2 × 2, para que as camadas seguintes considerem uma região maior.
  • Camadas totalmente conectadas transformam as características em uma resposta final, como “gato: 94%”.
Imagem de entrada32×32×3
Convoluçãomapas de bordas e texturas
Poolingreduz e mantém o maior valor
Convoluçãomapas de formas e partes
Vetorização + camada densacombina as características
Saída"gato" 92%
Imagem de entrada32×32×3Convoluçãomapas de bordas e texturasPoolingreduz e mantém o maior valorConvoluçãomapas de formas e partesVetorização + camada densacombina as característicasSaída"gato" 92%
Uma rede neural convolucional passa a imagem por filtros que transformam pixels gradualmente em uma decisão.

Principais conclusões

  • Uma imagem é uma matriz de valores de pixel (três matrizes para uma imagem colorida).

  • A convolução desliza um pequeno filtro pela imagem e calcula uma soma ponderada em cada posição.

  • Uma CNN aprende seus filtros, reduz mapas com pooling e combina bordas → formas → objetos.

Quiz da aula

6 perguntas · aprovação com 5 acertos · até 50 XP

Ao passar, você conclui a aula e mantém sua sequência. As perguntas erradas voltarão em sessões de revisão.

Pratique: escreva código em Python

Escreva código Python no editor e execute os testes com exemplos. O Python roda localmente no navegador usando WebAssembly.

Exercício 1

Faça a convolução de uma imagem

+25 XP

As três primeiras linhas formam um filtro 3 × 3. As linhas seguintes formam uma imagem (números separados por espaços). Deslize o filtro por todas as posições em que ele caiba por completo (sem preenchimento) e imprima a imagem de saída, uma linha por vez, com valores separados por espaços. Formate os números com :g.

  • Borda vertical
  • Desfoque em caixa
main.py
Carregando editor…

O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.

Exercício 2

Aplique max pooling a um mapa de características

+25 XP

Cada linha de entrada é uma linha do mapa de características, com quantidade par de linhas e colunas. Aplique max pooling 2 × 2: divida em blocos 2 × 2 sem sobreposição e mantenha o maior valor de cada bloco. Imprima o mapa reduzido, uma linha por vez, com valores separados por espaços.

  • Quatro por quatro
  • Dois por seis
main.py
Carregando editor…

O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.

Dúvidas sobre esta lição

Travou em algum ponto? Pergunte. Descobriu algo? Compartilhe. Explicar também é uma ótima forma de aprender.

Carregando publicações…