CS Fundamentals Trainer · Guias

Métricas perceptuais aprendidas: LPIPS, perdas perceptuais, transferência de estilo e DeepDream

Por que o PSNR e o SSIM enganam (com números reproduzíveis) e como as características profundas resolvem isso: a distância LPIPS e os julgamentos humanos do BAPPS por trás dela, como usar o LPIPS e a pyiqa e escolher entre métricas, perdas de características (perceptuais), transferência neural de estilo e a matriz de Gram como alinhamento de distribuições, o DeepDream como subida de gradiente sobre a imagem, o compromisso entre percepção e distorção e as armadilhas das métricas aprendidas.

32 min de leitura

O PSNR e o SSIM comparam duas imagens número a número, ou janela a janela. São baratos, bem conhecidos e muitas vezes errados sobre o que uma pessoa vê: uma imagem deslocada em um pixel parece idêntica e recebe nota ruim, enquanto uma imagem borrada e uma imagem com ruído de mesmo erro recebem a mesma nota. Desde cerca de 2016, outra ideia dominou os lugares em que um programa compara imagens: passar as duas imagens por uma rede neural pré-treinada e comparar o que a rede enxerga, em vez do que os pixels são. Essa única ideia dá uma métrica perceptual (LPIPS), as funções de perda por trás da maioria dos modelos de super-resolução e de imagem para imagem (perdas perceptuais), a transferência neural de estilo e o DeepDream.

Este guia liga essas quatro coisas, porque são a mesma ferramenta usada para quatro tarefas. Ele explica por que as métricas de pixel falham, com números que você pode reproduzir, como o LPIPS transforma características de uma rede em uma distância e como foi validado contra julgamentos humanos, como usá-lo, e a seus vizinhos, numa caixa de ferramentas como a pyiqa, por que as matrizes de Gram capturam o "estilo", o que o DeepDream faz de diferente e onde as próprias métricas aprendidas enganam. Cada afirmação está ligada à sua fonte, e os pequenos experimentos estão no apêndice.

Leia isto primeiro: o LPIPS é uma distância entre duas imagens, não uma nota de qualidade. Ele responde "quão diferentes estas duas imagens parecem a uma rede treinada?", precisa de uma referência e herda os vieses de sua rede de base e dos dados a que foi ajustado. Um LPIPS baixo significa "parecida com a referência", o que não é elogio se a referência for ruim, e uma métrica ajustada a julgamentos humanos sobre recortes de 64×64 não tem garantia de concordar com as pessoas no seu tipo de imagem (seção 6).

O que foi reproduzido e o que foi relatado. | Tipo | O que abrange | Situação | |---|---|---| | Reproduzido | A tabela de PSNR e SSIM da seção 1; a invariância da matriz de Gram a embaralhamentos e a identidade com a MMD da seção 5 | Executado para este guia (NumPy, SciPy, scikit-image, Pillow; a imagem de teste astronaut de 512×512 em cinza de 8 bits). Os programas estão no apêndice | | Relatado | Todo número ou afirmação sobre LPIPS, BAPPS, DISTS, MUSIQ, CLIP-IQA, transferência de estilo, Johnson e percepção-distorção | Citado das fontes da lista final, sem medição nova: os pesos pré-treinados não puderam ser baixados onde o guia foi escrito | | Fornecido, não executado | Um script opcional que acrescenta uma coluna de LPIPS à tabela da seção 1 e um exercício com os pesos da transferência de estilo | No apêndice, com sugestões de versões de pacotes; trate como não testado até você executá-lo |

1. Por que as métricas de pixel não bastam

Pegue uma fotografia em tons de cinza e estrague-a de cinco maneiras. As três primeiras são ajustadas para o mesmo erro quadrático médio (MSE), então o PSNR não consegue distingui-las. PSNR e SSIM maiores significam "mais parecida".

DistorçãoMSEPSNR (dB)SSIM
Deslocada 1 pixel para a direita263,623,920,857
Desfoque gaussiano, σ = 2,46264,823,900,786
Ruído gaussiano somado, σ = 17,2265,923,880,469
Brilho aumentado em 10 níveis (invisível para a maioria)99,028,170,880
JPEG, qualidade 10 (blocos visíveis)83,828,900,859

Três lições saem dessa tabela.

  1. Erro igual não é aparência igual. As três primeiras linhas têm o mesmo PSNR com diferença de 0,04 dB, mas ninguém diria que um deslocamento de um pixel é tão ruim quanto muito ruído. O SSIM as separa, porque olha a estrutura local: a imagem com ruído cai a 0,469, enquanto a deslocada fica em 0,857.
  2. Uma mudança inofensiva pode pontuar pior que uma nociva. Subir o brilho em 10 níveis de cinza custa 28,17 dB, que é menos que os 28,90 dB de um JPEG com blocos na qualidade 10. O PSNR vê só o tamanho da diferença, não se alguém a notaria.
  3. Métricas de pixel supõem alinhamento. O PSNR compara a posição i com a posição i. Um deslocamento de um pixel não muda nada que o olho note e muda todos os termos da soma.

Os autores do SSIM fizeram a mesma observação com uma fotografia chamada "Boat". Todas as suas versões distorcidas têm MSE de 210 e, no entanto, parecem muito diferentes: o índice estrutural dá 0,9900 à cópia com média deslocada, 0,9168 à de contraste esticado, 0,7748 ao ruído de sal e pimenta, 0,7052 à cópia borrada e 0,6949 ao JPEG. O SSIM trabalha com uma janela deslizante (gaussiana 11×11 com σ = 1,5), multiplica um termo de luminância, um de contraste e um de estrutura calculados a partir das médias, variâncias e covariância da janela (com pequenas constantes de estabilização, K₁ = 0,01 e K₂ = 0,03) e promedia os valores locais no SSIM médio. Uma mudança uniforme de brilho mantém a estrutura local, e por isso mal reduz a nota, de acordo com a terceira lição.

Essa é a motivação por trás do LPIPS: PSNR e SSIM são descritos como "funções simples e rasas" que perdem muitos aspectos da percepção humana. O remédio padrão antes do aprendizado profundo era modelar o sistema visual à mão, como fazem o VIF e o FSIM. A descoberta por trás do LPIPS é que uma rede treinada para outra coisa, como classificar o ImageNet, já contém um modelo de similaridade perceptual melhor que esses construídos à mão.

2. De características a uma distância: o LPIPS

O que é uma "característica profunda"

Uma rede convolucional transforma uma imagem em uma pilha de mapas de características, um conjunto por camada. As camadas iniciais respondem a bordas, cores e pequenas texturas; as mais profundas respondem a padrões maiores, como grades, pelos, rodas ou rostos, e cobrem uma parte maior da imagem (um campo receptivo maior). O conjunto de mapas de uma camada, com formato C canais × H × W posições, é a descrição da imagem naquele nível de abstração. Duas imagens próximas numa camada profunda têm o mesmo tipo de conteúdo e de textura, mesmo que seus pixels difiram.

A distância LPIPS

O LPIPS, Learned Perceptual Image Patch Similarity (similaridade perceptual aprendida entre recortes de imagem), é calculado em cinco passos:

  1. Passe a referência x e a imagem de teste x₀ pela mesma rede e colete as ativações de várias camadas.
  2. Em cada camada, normalize para norma unitária ao longo dos canais em cada posição.
  3. Multiplique cada canal por um peso aprendido w.
  4. Calcule a diferença quadrática L2 e tire a média sobre todas as posições espaciais.
  5. Some as camadas.

Diagram: How LPIPS turns two images into one number

Com todos os pesos iguais a 1, a fórmula se reduz, em cada posição, à distância euclidiana ao quadrado entre dois vetores de comprimento unitário, que é igual a 2(1 − cos θ): proporcional à distância do cosseno, mas não numericamente idêntica a ela. Os pesos aprendidos são o "L" de LPIPS: eles dizem quais canais importam para o julgamento humano.

As três maneiras de obter os pesos

VarianteO que é treinadoPonto de partida
linApenas um conjunto de pesos não negativos por canal; a rede fica congelada (1.472 parâmetros para o VGG)Um classificador pré-treinado
tuneTodos os pesos, ajustados finamente com os julgamentos humanosUm classificador pré-treinado
scratchTodos os pesos, a partir do zeroInicialização gaussiana aleatória

"lin" é o que a maioria das pessoas quer dizer com LPIPS. É uma calibração de um espaço de características existente, não uma rede nova, e por isso a métrica é barata de treinar e vem em várias redes de base: AlexNet, VGG e SqueezeNet.

Os dados: o BAPPS e como foram julgados

Os pesos foram ajustados, e a métrica testada, com o conjunto Berkeley-Adobe Perceptual Patch Similarity (BAPPS): 484.000 julgamentos humanos sobre 161.000 recortes de 64×64 pixels. Os recortes foram distorcidos de três modos: distorções tradicionais (20 básicas e 308 combinações em sequência: mudanças fotométricas, ruído, desfoque, deformações, JPEG), distorções baseadas em CNN (96 autocodificadores de remoção de ruído treinados no ImageNet, cujos artefatos lembram os de redes de restauração reais) e as saídas reais de algoritmos de super-resolução, interpolação de quadros, remoção de desfoque e colorização.

Dois tipos de teste foram usados:

O que os resultados mostram

Concordância média no 2AFC sobre os seis conjuntos de teste do artigo (maior é melhor):

MétodoConcordância com humanos
Avaliadores humanos (o teto)73,9%
L2 (o erro de pixel por trás do PSNR)63,2%
SSIM63,1%
FSIM63,8%
Características do VGG, usadas como estão67,0%
AlexNet-lin69,8%
VGG-lin69,2%
SqueezeNet-lin70,0%

Leia a tabela com cuidado, porque é fácil exagerar. O teto humano é 73,9%, não 100%, porque as pessoas discordam entre si nos pares difíceis; a comparação útil é, portanto, a distância que se fecha: métricas de pixel chegam a cerca de 63%, métricas aprendidas a cerca de 70%, humanos a 74%. Além disso, as métricas clássicas não são igualmente ruins em toda parte. O artigo registra L2, SSIM e FSIM com 77,8%, 79,1% e 78,6% nas distorções baseadas em CNN, mas só 59,9%, 60,3% e 61,4% nas tradicionais. A fraqueza delas se concentra em distorções como desfoque e mudanças geométricas.

Dois outros resultados explicam o título do artigo. Primeiro, características de redes autossupervisionadas e não supervisionadas (treinadas sem rótulos de classe) também superam as métricas clássicas, e o mesmo vale para redes treinadas para outras tarefas e com outras arquiteturas. Segundo, uma rede inicializada aleatoriamente se sai melhor que o L2 mas muito pior que uma treinada (64,3% contra cerca de 68 a 70%), então algum sinal de treinamento importa. Os autores concluem que a similaridade perceptual é "uma propriedade emergente compartilhada entre representações visuais profundas".

3. Usando essas métricas na prática

LPIPS, um par por vez

A implementação de referência é o pacote lpips. Sua documentação (página no PyPI) pede tensores RGB de formato N×3×H×W normalizados para [−1, 1], e diz que "maior significa mais distante/diferente, menor significa mais parecido". Ela descreve net='alex' como o padrão, o mais rápido e o melhor como métrica direta, e net='vgg' como "mais próximo da perda perceptual tradicional", o que se escolhe quando a distância é retropropagada como perda.

import lpips, torch
loss_fn = lpips.LPIPS(net='alex')                # downloads the AlexNet weights and the linear layer on first use
d = loss_fn(img_ref, img_test)                    # tensors N x 3 x H x W in [-1, 1]
print(d.item())                                   # lower = more similar; 0 = identical

O trecho segue a documentação do pacote e não foi executado para este guia (o ambiente não conseguiu baixar os pesos). Confira com a versão que você instalar.

Muitas métricas numa só interface: pyiqa

A caixa de ferramentas pyiqa "é uma caixa de ferramentas de avaliação de qualidade de imagem feita com Python e PyTorch", que oferece métricas com referência completa, sem referência e específicas de tarefa, com implementações calibradas contra as oficiais em MATLAB ou Python quando existem. Seus módulos de arquitetura incluem lpips_arch, dists_arch, niqe_arch, brisque_arch, musiq_arch e clipiqa_arch. O valor prático é que um script de avaliação pode percorrer nomes de métricas e informar o sentido de cada uma: em algumas, menor é melhor (LPIPS, NIQE, BRISQUE); em outras, maior (PSNR, SSIM, MUSIQ). A caixa de ferramentas expõe isso para cada métrica, então leia em vez de supor.

Escolhendo a métrica para a pergunta

PerguntaMétrica razoávelPrecisa de referência?Notas
Este codec ou filtro preservou o sinal?PSNR, SSIMSimBaratos e bem compreendidos; enganam com deslocamentos, desfoque e ruído (seção 1)
Esta imagem restaurada se parece com a original?LPIPS, DISTSSimO LPIPS é mais sensível à estrutura; o DISTS tolera explicitamente a reamostragem de textura
Qual saída de GAN ou de difusão parece mais natural?LPIPS para fidelidade, mais um teste sem referência ou humanoMistoFidelidade e realismo puxam em direções opostas (seção 6)
Quão boa é esta foto sem o original?NIQE, BRISQUE, MUSIQ, CLIP-IQANãoTreinadas em estatísticas de imagens naturais ou em dados de opinião; confira o domínio do conjunto de treino
O que as pessoas realmente dizem?Um teste subjetivo (MOS, comparação par a par)OpcionalA referência para todo o resto; informe SROCC e PLCC contra ele (veja o parágrafo abaixo)

Vizinhos que vale conhecer: DISTS, MUSIQ e CLIP-IQA

O DISTS (Deep Image Structure and Texture Similarity) é um índice de referência completa criado para corrigir uma fraqueza do LPIPS e do SSIM: eles são "excessivamente sensíveis à reamostragem de regiões de textura". Uma fotografia de grama em que cada folha foi redesenhada é a mesma textura do original, mas é outro arranjo de pixels, então medidas pixel a pixel a julgam pior que um JPEG levemente comprimido do original, contra o que as pessoas dizem. O DISTS usa uma VGG16 fixa (com o max pooling trocado por um pooling ℓ2 suavizado, para reduzir o aliasing) e compara duas coisas em cada estágio: as médias espaciais dos mapas de características (o termo de textura) e suas correlações espaciais (o termo de estrutura, no estilo do SSIM). Nos recortes do BAPPS ele obtém 0,689 contra 0,692 do LPIPS, embora não tenha sido treinado neles; no banco de qualidade TID2013 sua PLCC é 0,855 contra 0,749; num banco de qualidade de texturas (SynTEX) sua SRCC é 0,923 contra 0,663. Os autores também apontam os limites: ele é altamente não convexo, o que dificulta usá-lo como perda de treino, e dá uma nota global, sem mapa de qualidade.

O MUSIQ é um modelo transformer sem referência que lê a imagem em sua resolução nativa e em várias escalas, com uma incorporação posicional por hash, em vez de redimensioná-la ou cortá-la antes. Isso importa porque redimensionar já é uma mudança de qualidade: uma CNN que exige tamanho fixo de entrada mede a imagem depois de danificada.

O CLIP-IQA é um método sem referência que não precisa de nenhum rótulo de qualidade. Ele pergunta a um modelo CLIP pré-treinado quão perto a imagem está de um par de comandos opostos, como "Good photo." e "Bad photo.", e transforma as duas similaridades em uma nota entre 0 e 1 com um softmax. O mesmo truque serve para outras qualidades ("brilhante" e "escura", "ruidosa" e "limpa", "nítida" e "borrada"). Os autores relatam que o resultado é sensível à redação ("Good/Bad" funcionou melhor que "High quality/Low quality"), que vocabulário profissional raro é difícil para o CLIP e que ainda há distância em relação a modelos treinados para a tarefa.

Valide contra pessoas, não contra outra métrica. Quando uma métrica nova ou aprendida é testada nos seus dados, colete notas de opinião numa amostra (um teste subjetivo conduzido nos moldes da ITU-R BT.500) e informe a SROCC (os postos concordam?) e a PLCC (a relação é linear após um ajuste monotônico?) entre a métrica e o MOS. É assim também que os artigos acima apresentam seus resultados.

4. De métrica a perda: perdas perceptuais

Tudo que é diferenciável e mede distância entre imagens pode ser minimizado. Redes feed-forward podem ser treinadas para transferência de estilo e super-resolução usando perdas perceptuais definidas sobre as características de uma rede pré-treinada, em vez de perdas por pixel. O resultado relatado é que uma rede de transferência de estilo treinada dá resultados qualitativamente semelhantes aos do método por otimização de Gatys et al., sendo "três ordens de grandeza mais rápida", e que na super-resolução uma perda perceptual dá resultados visualmente mais agradáveis que uma por pixel.

O motivo é o mesmo da seção 1. Uma perda por pixel (MSE) é minimizada pela média de todas as respostas plausíveis, que é borrada: se uma borda nítida pudesse estar um pixel à esquerda ou à direita, a média das duas é uma borda esfumaçada. Uma perda de características não penaliza com tanta força a posição exata de um detalhe de textura, então a rede fica livre para produzir uma borda nítida em um lugar.

O LPIPS é usado do mesmo modo: como termo de treinamento, como nota de seleção de modelo, ou ambos. Esse também é seu principal risco, tratado na seção 6.

5. Transferência neural de estilo e a matriz de Gram

O procedimento

A versão por otimização da transferência neural de estilo parte de uma imagem (a de conteúdo ou ruído) e muda seus pixels, não a rede, até que duas perdas fiquem pequenas. O método por trás dele usa as camadas convolucionais da VGG-19 (o original troca o max pooling por average pooling, o que "melhora o fluxo do gradiente"). O conteúdo é a resposta de características de uma camada mais alta (conv4_2). O estilo é o conjunto das matrizes de Gram de cinco camadas (conv1_1 a conv5_1, cada uma com peso 1/5), uma descrição multiescala, semelhante a textura, que deixa de fora a disposição global. A imagem é produzida por descida de gradiente sobre uma imagem de ruído branco para minimizar α·(perda de conteúdo) + β·(perda de estilo), e a razão α/β é o botão entre as duas: um peso de estilo alto dá uma pintura texturizada com pouca foto visível, um peso de conteúdo alto mantém a fotografia reconhecível mas iguala menos o estilo. A descoberta central dos autores é que "as representações de conteúdo e de estilo na rede neural convolucional são separáveis", embora não por completo: igualar os dois ao mesmo tempo perfeitamente costuma ser impossível. O tutorial do PyTorch implementa a mesma ideia com algumas diferenças, assim:

Trate estes números como ajustes de uma implementação, não como padrões do método. A formulação original usa outra normalização das perdas e expressa o equilíbrio como uma razão α/β de 10⁻³ ou 10⁻⁴, então o 10⁶ do tutorial não se transfere para outro código, e as camadas (conv_4 contra conv4_2) também diferem. Mudar os pesos muda o resultado no sentido descrito pelo artigo original (mais peso de estilo, mais textura e menos fotografia visível), então o exercício útil é repetir uma execução com vários pesos e olhar (uma varredura sugerida está no apêndice; não foi executada para este guia).

O que é uma matriz de Gram e o que ela descarta

Reorganize os mapas de características de uma camada numa matriz F com uma linha por canal (K linhas) e uma coluna por posição (N colunas). A matriz de Gram é G = F Fᵀ, uma tabela K×K de quanto cada par de canais está ativo ao mesmo tempo. O tutorial então a normaliza: "a matriz de Gram deve ser normalizada dividindo cada elemento pelo número total de elementos da matriz", para que camadas grandes não dominem a perda.

A propriedade importante é o que G não contém: onde as coisas estão. A soma sobre as posições é a mesma em qualquer ordem. Isso é conferido diretamente no apêndice: embaralhar as colunas de F muda por completo os mapas de características e deixa G exatamente igual (np.allclose devolve True). Assim, igualar matrizes de Gram iguala as estatísticas de coocorrência das características, que são textura e paleta de cores, sem igualar sua disposição. Essa é uma definição prática de "estilo" por oposição a "conteúdo", e a razão de a perda de conteúdo ser tomada sobre os próprios mapas de características (que guardam a disposição) e a perda de estilo sobre suas matrizes de Gram.

Por que isso funciona, em um resultado

Há uma razão precisa para as matrizes de Gram capturarem estilo. Pode-se mostrar que igualar matrizes de Gram é matematicamente equivalente a minimizar a discrepância máxima de médias (MMD) com um núcleo polinomial de segunda ordem, de modo que a transferência de estilo é, na prática, alinhar a distribuição das características da imagem gerada com a da imagem de estilo. Isso é sustentado por bons resultados também com outros métodos de alinhamento de distribuições.

A equivalência é fácil de conferir numericamente. Para dois conjuntos de vetores de características, a MMD com núcleo k(x, y) = (x·y)² é igual à distância de Frobenius ao quadrado entre suas matrizes de segundo momento (normalizadas pela média). O apêndice calcula as duas em dados aleatórios e imprime 4.367194382521898 e 4.367194382521896: iguais até o erro de arredondamento.

A versão rápida

O método do tutorial roda uma otimização para cada novo par de imagens. Uma rede feed-forward pode ser treinada uma vez por estilo, usando as mesmas perdas de conteúdo e de estilo como sinal de treino, de modo que estilizar uma nova imagem é uma única passada direta. São as "três ordens de grandeza" da seção 4.

6. Onde as métricas aprendidas enganam

  1. Elas valem tanto quanto sua distribuição de treino. O LPIPS foi ajustado a recortes de 64×64 e às distorções do BAPPS. Em outros conteúdos (imagens médicas, desenho de linhas, imagens muito grandes, um novo tipo de artefato), sua concordância com as pessoas precisa ser reverificada, não presumida.
  2. Fidelidade e realismo são objetivos diferentes, e há um compromisso entre eles. Pode-se mostrar que "distorção e qualidade perceptual estão em conflito": quando a distorção média em relação à verdade de referência cai, a melhor qualidade perceptual possível tem de piorar, para qualquer medida de distorção. O efeito é mais fraco em algumas medidas, como distâncias entre características do VGG. Logo, um método que vence no PSNR não é o que parece mais real, e uma GAN que parece real perde no PSNR. Informe os dois lados e diga qual deles você otimizou.

Leia com cuidado o alcance desse resultado. Ele descreve os melhores pares possíveis de (distorção, qualidade perceptual), em que a qualidade perceptual é definida pela facilidade com que um discriminador ótimo distingue imagens restauradas de reais. É uma afirmação sobre um limite, não uma garantia sobre um modelo ou benchmark específico: um modelo real pode ficar longe do limite, a força do conflito depende da medida de distorção usada, e notas de opinião humana são outra operacionalização de "qualidade perceptual" que não a baseada em discriminador.

  1. Uma métrica usada como perda é explorada. Depois que uma rede é treinada para minimizar o LPIPS, um LPIPS baixo deixa de medir algo independente. Use uma métrica separada do treino ou um teste humano para avaliá-la, e mantenha uma métrica diferente no treino e na nota final.
  2. Uma distância não é uma nota de qualidade. O LPIPS compara duas imagens. Ele diz "estas se parecem", não "esta é boa". Se a própria referência for ruim, um LPIPS baixo não é elogio.
  3. Números de ferramentas diferentes não são comparáveis. O mesmo nome de métrica pode diferir entre implementações na faixa de cores (0–1 ou −1–1), na rede de base e no redimensionamento. Informe os três ao publicar um resultado.

7. DeepDream: a mesma máquina com outro objetivo

Na transferência de estilo, a perda compara uma imagem com uma imagem-alvo. O DeepDream faz outra pergunta: o que faria esta camada responder mais? Em junho de 2015 o Google publicou o texto Inceptionism, e em julho o exemplo de código do DeepDream. A rede é a construída para o desafio ImageNet de 2014.

O relato do próprio Google, o texto Inceptionism, dá a intuição mais clara. Pedir a uma camada que "amplifique o que você vê ali" cria um ciclo de realimentação, e o que aparece depende da camada. As camadas baixas respondem a bordas e orientações e produzem traços e padrões simples de ornamento; as camadas intermediárias produzem formas e componentes, como portas ou folhas; as camadas altas produzem objetos inteiros, como pássaros, prédios ou torres. A imagem também é enviesada pelos dados de treino e pela entrada: uma rede treinada sobretudo com animais vê animais em formas aleatórias, linhas de horizonte viram torres e folhas atraem pássaros e insetos. Realimentar a saída, com um zoom a cada passada, gera um fluxo sem fim de imagens novas. Partir de ruído puro funciona mal, a menos que a imagem seja restringida a ter estatísticas de imagens naturais, como pixels vizinhos correlacionados. Os autores apresentam a técnica sobretudo como um modo de ver o que uma rede aprendeu, de checar se o treino captou as características certas e, possivelmente, de melhorar arquiteturas, com a arte como uso secundário.

Os pesos ficam fixos, como na transferência de estilo. O que muda é a imagem de entrada: ela é ajustada para que um neurônio de saída escolhido receba uma pontuação de confiança maior, procedimento que lembra a retropropagação com os papéis trocados (atualiza-se a imagem, não os pesos). Como o texto do Google descreve, você escolhe uma camada e pede à rede que amplifique o que essa camada detecta, o que é subida de gradiente sobre a imagem. Otimizar uma imagem a partir de ruído funciona mal sozinho e funciona muito melhor quando a imagem é restringida a ter estatísticas de imagens naturais, como pixels vizinhos correlacionados. Aplicada a uma foto comum, a rede amplifica o que meio que reconhece ali, e é por isso que surgem redemoinhos de olhos, pelos e arquitetura: é uma forma de pareidolia, o mesmo efeito de ver rostos em nuvens.

Transferência neural de estiloDeepDream
O que mudaOs pixels da imagemOs pixels da imagem
O que fica fixoA redeA rede
ObjetivoIgualar características de conteúdo e estatísticas de estilo (Gram) de duas imagens-alvoAumentar a ativação de um neurônio ou camada escolhidos
Precisa de imagem-alvo?Sim, duasNão
Uso principalSíntese de imagens, arteVisualizar o que uma camada aprendeu; arte

Ambos são instâncias de uma só técnica: tomar o gradiente de um objetivo no espaço de características em relação à imagem. O LPIPS como perda é a terceira instância. Quem entende as três entende também como se fazem exemplos adversariais, pois eles usam o mesmo gradiente com outro objetivo.

8. Que ferramenta para qual pergunta

Você quer…UsePorque
Conferir que uma etapa sem perdas ou quase sem perdas manteve os pixelsMSE ou PSNRNão há pergunta perceptual a responder
Comparar codecs na mesma taxa de bitsSSIM ou VMAF, mais um pequeno teste subjetivoA estrutura importa mais que o erro de pixel
Ordenar saídas de restauração ou super-resolução contra uma verdade de referênciaLPIPS (ou DISTS), informado junto com o PSNRSegue melhor os julgamentos humanos de similaridade, e o PSNR mostra o lado da fidelidade no compromisso
Treinar uma rede de restauração ou de estiloUma perda de características (baseada em VGG), possivelmente com um termo adversarialPerdas por pixel dão saídas borradas
Avaliar fotos sem referênciaNIQE, BRISQUE, MUSIQ, CLIP-IQAPrecisam só da imagem de teste
Entender o que uma camada aprendeuMaximização de ativação no estilo DeepDreamMostra o que excita a camada
Produzir uma imagem estilizada a partir de duas fotografiasO método da matriz de Gram (lento) ou uma rede feed-forward treinada (rápida)Otimiza-se por par ou uma vez por estilo
Decidir se uma métrica merece confiança nas suas imagensColetar MOS numa amostra e informar SROCC e PLCCSó as pessoas definem a qualidade perceptual

9. Erros comuns

10. O que mencionar numa entrevista

Resumo rápido

Apêndice: o código

metrics/experiment.py

# Section 1: how PSNR and SSIM score five changes to the same picture.
# pip install numpy scipy scikit-image pillow
import io
import numpy as np
from PIL import Image
from scipy.ndimage import gaussian_filter
from skimage import color, data
from skimage.metrics import mean_squared_error as mse
from skimage.metrics import peak_signal_noise_ratio as psnr
from skimage.metrics import structural_similarity as ssim

img = (color.rgb2gray(data.astronaut()) * 255).round().astype(np.uint8)
f = img.astype(float)


def clip(a):
    return np.clip(a.round(), 0, 255).astype(np.uint8)


def report(name, t):
    print(f"{name:38s} MSE {mse(img, t):8.1f}  PSNR {psnr(img, t, data_range=255):6.2f}  "
          f"SSIM {ssim(img, t, data_range=255):.3f}")


rng = np.random.default_rng(0)
report("brightness +10", clip(f + 10))
report("shift 1 px right", clip(np.roll(f, 1, axis=1)))
report("shift 2 px right", clip(np.roll(f, 2, axis=1)))

target = mse(img, clip(np.roll(f, 1, axis=1)))   # tune blur and noise to the MSE of the 1 px shift
for s in np.arange(0.5, 6, 0.01):
    blurred = clip(gaussian_filter(f, s))
    if mse(img, blurred) >= target:
        break
report(f"blur sigma {s:.2f} (MSE matched)", blurred)

for sd in np.arange(1, 80, 0.1):
    noisy = clip(f + rng.normal(0, sd, f.shape))
    if mse(img, noisy) >= target:
        break
report(f"noise sd {sd:.1f} (MSE matched)", noisy)

for q in (90, 50, 20, 10):
    buf = io.BytesIO()
    Image.fromarray(img).save(buf, "JPEG", quality=q)
    report(f"JPEG quality {q}", np.array(Image.open(buf)))

gram/check.py

# Section 5: a Gram matrix ignores where features are, and equals an MMD with a polynomial kernel.
import numpy as np

rng = np.random.default_rng(1)
F = rng.normal(size=(8, 16 * 16))                 # K = 8 channels, N = 256 positions
G = F @ F.T / F.size                              # normalised as in the PyTorch tutorial
perm = rng.permutation(F.shape[1])
G2 = F[:, perm] @ F[:, perm].T / F.size
print("same Gram after shuffling positions:", np.allclose(G, G2),
      "| feature maps equal:", np.allclose(F, F[:, perm]))

X = F.T                                           # N points in R^K
Y = rng.normal(size=(300, 8)) * 1.3


def mmd(X, Y):
    k = lambda A, B: (A @ B.T) ** 2               # second-order polynomial kernel
    return k(X, X).mean() + k(Y, Y).mean() - 2 * k(X, Y).mean()


Gx, Gy = X.T @ X / len(X), Y.T @ Y / len(Y)
print(mmd(X, Y), ((Gx - Gy) ** 2).sum())          # equal

neural/lpips_table.py (opcional, não executado)

# Optional and NOT run for this guide: adds an LPIPS column to the distortions of section 1.
# Suggested pins (a matching torch/torchvision pair; adjust to your platform):
#   pip install "torch==2.5.1" "torchvision==0.20.1" "lpips==0.1.4" numpy scipy scikit-image pillow
# The first call downloads the AlexNet weights through torchvision; the linear LPIPS weights ship with the package.
import io

import lpips
import numpy as np
import torch
from PIL import Image
from scipy.ndimage import gaussian_filter
from skimage import color, data

img = (color.rgb2gray(data.astronaut()) * 255).round().astype(np.uint8)
f = img.astype(float)
rng = np.random.default_rng(0)


def clip(a):
    return np.clip(a.round(), 0, 255).astype(np.uint8)


def jpeg(a, q):
    buf = io.BytesIO()
    Image.fromarray(a).save(buf, "JPEG", quality=q)
    return np.array(Image.open(buf))


variants = {
    "brightness +10": clip(f + 10),
    "shift 1 px right": clip(np.roll(f, 1, axis=1)),
    "blur sigma 2.46": clip(gaussian_filter(f, 2.46)),
    "noise sd 17.2": clip(f + rng.normal(0, 17.2, f.shape)),
    "JPEG quality 10": jpeg(img, 10),
}


def to_tensor(a):                                  # grey 8-bit -> 1 x 3 x H x W in [-1, 1], as the lpips docs ask
    t = torch.from_numpy(a.astype(np.float32) / 127.5 - 1.0)
    return t[None, None].repeat(1, 3, 1, 1)


loss_fn = lpips.LPIPS(net="alex").eval()           # lower = more similar
with torch.no_grad():
    for name, v in variants.items():
        print(f"{name:20s} LPIPS(alex) {loss_fn(to_tensor(img), to_tensor(v)).item():.3f}")

# Exercise for the style-transfer sensitivity (not provided as code): in the PyTorch tutorial, repeat the run with
# style_weight in {1e4, 1e5, 1e6, 1e7} and content_weight = 1, and compare the outputs. The original formulation
# uses a different loss normalisation and ratios (alpha/beta of 1e-3 and 1e-4), so the tutorial's numbers do not transfer.

Fontes

Pratique este tema: Computer Vision

Mais guias