O reconhecimento facial é um dos campos que emprega a aprendizagem automática e é amplamente utilizado em muitas áreas, desde etiquetar fotos em redes sociais e combinar pessoas com as mesmas características faciais em sites de namoro, à localização de criminosos e segurança de fronteiras, até manter os grandes apostadores à distância em cassinos.

Acho fascinante que possamos simular o processo de reconhecimento facial com um grau significativo de precisão, ao mesmo tempo que há pessoas que sofrem de prosopagnosia, ou “cegueira facial”, que não têm tanta sorte. Um autor de um artigo Cracked que encontrei há algum tempo atrás descreve esta experiência como vendo uma pilha de LEGOs onde, assim que se olha para o lado, já não se consegue descrever com nenhum detalhe substancial a cor e forma que cada peça tinha ou como estava posicionada. Eu me perguntei se este distúrbio cognitivo tem algo a ver com a alocação de memória. Felizmente, a memória é algo que os computadores têm em abundância e ainda nem sequer começámos a arranhar a superfície de todo o conjunto de capacidades que a computação quântica irá apresentar.

But back to eigenfaces.

Os dados visuais de uma imagem podem ser mapeados para um vector onde cada entrada representa o brilho do pixel correspondente. Ao pegar um conjunto de imagens, uma matriz pode então ser construída com cada linha correspondente a um vetor de imagem específico. Idealmente, as imagens são primeiro normalizadas de forma a alinhar características básicas como olhos, nariz e boca para aumentar a precisão e reduzir o ruído. As faces próprias são então os vetores próprios que são derivados da matriz de covariância desta matriz de dados faciais analisados.

O conjunto de dados de faces que usamos foi gentilmente fornecido pelo AT&T Laboratórios em Cambridge e consistiu de 40 faces individuais, 10 imagens de cada uma com expressões faciais e posições de cabeça variáveis.

5497>

5497>

As seguintes bibliotecas e módulos Python foram utilizados neste exercício:

from sklearn.preprocessing import normalize
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt
from scipy.misc import imread
from itertools import chain
import numpy as np
import scipy as sp
import glob

• normalize escalas de função de cada vector de amostra individual para ter uma norma unitária.
• PCA ou Análise de Componentes Princípio, é um processo de redução de dimensionalidade linear usando Decomposição de Valor Singular dos dados para projetá-los a um espaço dimensional inferior. Em outras palavras, é o processo de encontrar a estrutura subjacente dos dados ou as direções em que há maior variação.
• matplotlib.pyplot é a função de plotagem familiar.
• imread é usado para ler em uma imagem de um arquivo como um array.
• chain é um iterador que percorre a lista retornando elementos individuais de cada iterável.
• numpy é o pacote Python fundamental para computação científica.
• scipy é outro pacote para computação científica e técnica, semelhante a numpy mas que contém versões mais completas dos módulos de álgebra linear, bem como muitos outros algoritmos numéricos.
• glob o módulo encontra todos os nomes de caminhos que correspondem a um padrão especificado.

O primeiro passo é extrair todos os nomes de arquivos compactados. Em seguida, uma matriz é criada desdobrando matrizes de imagens em vetores usando o comando chain e empilhando-as. Isto cria uma matriz 400×10304 com cada linha contendo todas as informações sobre uma imagem 112×92 específica.

filenames = m = for i in range(400)]for i in range(400):
m = list(chain.from_iterable(imread(filenames)))
m = np.matrix(m)

Próximo, a matriz é normalizada e o PCA é aplicado. Aqui reduzimos nosso espaço vetorial para apenas 40 de 10304 dimensões:

model = PCA(n_components=40)
pts = normalize(m)
model.fit(pts)
pts2 = model.transform(pts)

Finalmente, as autofaces, contidas em model.components_, podem ser exibidas:

fig, ax = plt.subplots(1,40)for i in range(40):
ord = model.components_
img = ord.reshape(112,92)
ax.imshow(img,cmap='gray')

5497>

> E aí a temos. Um monte de rostos assustadores.

O que essencialmente fizemos é criar um conjunto de bases ortogonais onde cada rosto próprio destaca um certo tipo de característica, e a partir do qual os rostos que usamos podem ser reconstruídos através de diferentes combinações e proporções de vetores próprios.

faces_pca = PCA(n_components=40)
faces_pca.fit(m)
components = faces_pca.transform(m)
projected = faces_pca.inverse_transform(components)fig, axes = plt.subplots(40,10,figsize=(20,80))
for i, ax in enumerate(axes.flat):
ax.imshow(projected.reshape(112,92),cmap="gray")

>>

Porque comprimimos tanto o nosso espaço vectorial (e não alinhamos as faces para começar), muito do detalhe se perdeu, mas as faces ainda assim permaneceram algo reconhecíveis.

E assim, o objetivo para o problema de visão computacional do reconhecimento de rostos humanos é criar o número mínimo de rostos próprios que possam representar adequadamente todo o conjunto de treinamento. Se o conjunto de treinamento for suficientemente diversificado, o conjunto resultante de auto-reflexos deve ser capaz de representar todos os rostos. E, embora tenham sido feitos progressos significativos nos últimos anos envolvendo algoritmos de reconhecimento facial, ainda há um longo caminho a percorrer e muitas melhorias a serem feitas.

Por outro lado, e como sempre, existem alguns perigos associados às capacidades sempre em expansão de software capaz de reconhecer, simular, e assim potencialmente enganar e manipular um indivíduo insuspeito, e devemos tomar as precauções adequadas para nos certificarmos de que é usado apropriadamente.

E vou deixar isto aqui como um caso em questão e para o seu entretenimento.