Aprendizado de máquina: reconhecer rostos usando eigenfaces

O reconhecimento facial é importante para o aprendizado de máquina. A capacidade de reconhecer um rosto na multidão tornou-se uma ferramenta essencial para muitas profissões. Por exemplo, tanto os militares e aplicação da lei dependem pesadamente. Claro, o reconhecimento facial tem usos para a segurança e outras necessidades também.

Video: Machine intelligence makes human morals more important | Zeynep Tufekci

Este exemplo olha para o reconhecimento facial em um sentido mais geral. Você pode ter se perguntado como as redes sociais conseguem marcar as imagens com o rótulo ou nome apropriado. O exemplo a seguir demonstra como executar esta tarefa, criando as características certas usando eigenfaces.

Eigenfaces é uma abordagem para o reconhecimento facial baseada na aparência geral de um rosto, e não em seus detalhes particulares. Por meio da técnica que pode interceptar e remodelar a variância presentes na imagem, a informação remodelada é tratado como o DNA de uma face, permitindo assim a recuperação de rostos semelhantes (porque eles têm variâncias semelhantes) numa série de imagens faciais.

É uma técnica menos eficaz do que a extração de características dos detalhes de uma imagem, mas ele funciona, e você pode implementá-lo rapidamente em seu computador. Esta abordagem demonstra como aprendizado de máquina pode operar com pixels crus, mas é mais eficaz quando você alterar os dados de imagem em outro tipo de dados. Você pode aprender mais sobre eigenfaces ou tentando o tutorial que explora decomposições de variância em Scikit-learn.

Neste exemplo, você usar eigenfaces associar imagens presentes em um treinamento conjunto com aqueles em um conjunto de teste, inicialmente utilizando algumas medidas estatísticas simples.

importar numpy como np

de fetch_olivetti_faces sklearn.datasets importação

conjunto de dados = fetch_olivetti_faces (Shuffle = true,

random_state = 101)

train_faces = dataset.data [: 350 ,:]

test_faces = dataset.data [350:,:]

train_answers = dataset.target [: 350]

test_answers = dataset.target [350:]

O exemplo começa usando o conjunto de dados Olivetti enfrenta, um conjunto de domínio público de imagens prontamente disponíveis a partir scikit-learn. Para esta experiência, o código divide o conjunto de imagens rotuladas em um treinamento e um conjunto de teste. Você precisa fingir que você sabe os rótulos do conjunto de treinamento, mas não sei nada do conjunto de teste. Como resultado, pretende associar imagens do conjunto de teste para a imagem mais semelhante a partir do conjunto de treinamento.

print (dataset.DESCR)

O conjunto de dados Olivetti consiste de 400 fotos tiradas a partir de 40 pessoas (por isso há 10 fotos de cada pessoa). Mesmo que as fotos representam a mesma pessoa, cada foto foi tomada em momentos diferentes durante o dia, com expressões diferentes de luz e faciais ou detalhes (por exemplo, com óculos e sem). As imagens são de 64 x 64 pixels, por isso se desdobrando todos os pixels em recursos cria um conjunto de dados feita de 400 casos e 4.096 variáveis. Parece que um elevado número de recursos, e de fato, é. utilização RandomizedPCA, você pode reduzi-los a um número menor e mais gerenciável.

de sklearn.decomposition RandomizedPCA importação

n_components = 25

RPCA = RandomizedPCA (n_components = n_components,

branquear = True,

random_state = 101) .fit (train_faces)

Video: TCC FEI - Reconhecimento de Imagens Baseadas em Caracteristicas

imprimir ( `variância explicada por% i componentes:% 0.3f` %

(n_components,

np.sum (Rpca.explained_variance_ratio_)))

compressed_train_faces = Rpca.transform (train_faces)

compressed_test_faces = Rpca.transform (test_faces)

variância explicada por 25 componentes: 0,794

o RandomizedPCA classe é uma versão PCA aproximada, que funciona melhor quando o conjunto de dados é grande (tem muitas linhas e variáveis). A decomposição cria 25 novas variáveis ​​(n_components de parâmetro) e branqueamento (branquear = True), Retirando algum ruído constante (criado por textuais e granularidade foto) e informações irrelevantes a partir de imagens de uma forma diferente dos filtros que acabamos de discutir. A decomposição resultante utiliza 25 componentes, o que é cerca de 80 por cento da informação mantida em 4.096 características.

Video: Rana el Kaliouby: This app knows how you feel — from the look on your face

matplotlib.pyplot importação como plt

foto = 17 # Esta é a foto no conjunto de teste

print ( `Estamos à procura de cara ID =% i`

% test_answers [foto])

plt.subplot (1, 2, 1)

plt.axis ( `off`)

plt.title ( `rosto desconhecido `+ str (foto) +` em conjunto test`)

plt.imshow (test_faces [foto] .reshape (64,64),

cmap = plt.cm.gray, interpolação = `mais próximo`)

plt.show ()

Aqui está a foto escolhida, número de registro assunto 34, a partir do conjunto de teste.

Após a decomposição do conjunto de teste, o exemplo leva os dados relativos apenas para foto 17 e subtrai-lo a partir da decomposição do conjunto de treinamento. Agora, o conjunto de treinamento é feito de diferenças em relação ao exemplo da foto. As praças codificá-las (para remover valores negativos) e resume-los por linha, o que resulta em uma série de erros somados. As fotos mais semelhantes são os únicos com os erros mínimos quadrados, ou seja, aqueles cujas diferenças são o mínimo.

#Just o vetor de componentes de valor de nossa foto

mask = compressed_test_faces [foto],

squared_errors = np.sum ((compressed_train_faces -

máscara) ** 2, eixo = 1)

minimum_error_face = np.argmin (squared_errors)

most_resembling = lista (np.where (squared_errors lt; 20) [0])

print ( `Melhor rosto que se assemelha em teste de comboio:% i` %

train_answers [minimum_error_face])

Melhor rosto lembrando no teste de trem: 34

Como fazia antes, o código agora pode exibir foto 17, que é a foto que melhor se assemelha imagens a partir do conjunto de trem.

matplotlib.pyplot importação como plt

plt.subplot (2, 2, 1)

plt.axis ( `off`)

plt.title ( `rosto desconhecido `+ str (foto) +` em conjunto test`)

plt.imshow (test_faces [foto] .reshape (64,64),

cmap = plt.cm.gray, interpolação = `mais próximo`)

Video: The wonderful and terrifying implications of computers that can learn | Jeremy Howard | TEDxBrussels

para K, m, em enumerar (most_resembling [: 3]):

plt.subplot (2, 2, 2 + k)

plt.title ( `Match em trem definir nenhuma.` + str (m))

plt.axis ( `off`)

plt.imshow (train_faces [m] .reshape (64,64),

cmap = plt.cm.gray, interpolação = `mais próximo`)

plt.show ()

Mesmo que a foto mais semelhante é semelhante (é apenas escalado de forma ligeiramente diferente), as outras duas fotos são bastante diferentes. No entanto, mesmo que essas fotos não correspondem à imagem de teste, bem, eles realmente mostram a mesma pessoa que na foto 17.