Aula 18 – Scikit-Learn – Reconhecimento facial – Avaliação qualitativa

Voltar para página principal do blog

Todas as aulas desse curso

Aula 17              Aula 19

Script dessa aula:

Download do script da aula

Documentação oficial do Sklearn:

https://scikit-learn.org/stable/

Reconhecimento facial – Avaliação qualitativa do modelo

Se gostarem do conteúdo dêem um joinha na página do Código Fluente no
Facebook

Link do código fluente no Pinterest

Meus links de afiliados:

Hostinger

Digital Ocean

One.com

Essa aula é baseada no trabalho apresentado no:

Labeled Faces in the Wild: A Database for Studying Face Recognition in Unconstrained Environments Gary B. Huang,Manu Ramesh, Tamara Berg, and Erik Learned-Miller

Para o download da base LFW é só clicar nesse link abaixo:

https://scikit-learn.org/stable/auto_examples/applications/plot_face_recognition.html

Ou da fonte original

http://vis-www.cs.umass.edu/lfw/

Avaliação qualitativa do classificador

Antes, vamos lembrar o que fizemos na aula passada.

Avaliação Quantitativa do Modelo

Os dois métodos quantitativos mais utilizados para análise de dados são estatística descritiva e estatística inferencial.

A estatística descritiva (também conhecida como análise descritiva) geralmente é o primeiro nível da análise.

Isso ajuda os pesquisadores a resumir os dados e encontrar padrões.

Algumas estatísticas descritivas usadas com frequência são:

• Média : média numérica de um conjunto de valores.
• Mediana : ponto médio de um conjunto de valores numéricos.
• Moda : valor mais comum entre um conjunto de valores.
• Porcentagem : proporção de uma quantidade ou grandeza em relação a uma outra avaliada sobre a centena.
• Frequência : o número de vezes que um valor é encontrado.
• Intervalo : o valor mais alto e mais baixo em um conjunto de valores.

Foi o que fizemos na aula passada.

Análise qualitativa

Nessa aula trataremos a parte do código referente a análise qualitativa do classificador criado, a parte em laranja no código abaixo.

Métodos Qualitativos de Análise de Dados

Vários métodos estão disponíveis para analise de dados qualitativos.

Os métodos mais usados ​​são:

• Análise de conteúdo: este é um dos métodos mais comuns para analisar dados qualitativos, é usado para analisar informações documentadas na forma de textos, mídia ou mesmo itens físicos.
• Análise narrativa: esse método é usado para analisar o conteúdo de várias fontes, dados textuais garimpados de variadas maneiras: pesquisas, crawlers, etc.
• Análise do discurso: a análise do discurso ou narrativa, é usada para analisar as interações com as pessoas, no entanto, concentra-se em analisar o contexto social em que ocorreu a comunicação.
• Teoria fundamentada: refere-se ao uso de dados qualitativos para explicar por que um determinado fenômeno aconteceu, isso é feito estudando uma variedade de casos semelhantes em diferentes configurações e usando os dados para derivar explicações da causa.

No caso aqui do exemplo da classificação das faces, usaremos o matplotlib para previsões da qualidade do modelo, plotando algumas imagens das faces, mostrando o valor correto e o valor previsto para as faces alvo.

Mostrando também algumas eingefaces.

Na verdade, são mostradas apenas 12 imagens, já que plot_gallery() foi definida dessa forma:

plot_gallery(images, titles, h, w, n_row=3, n_col=4)

Então, 3 X 4 = 12, serão plotadas 12 imagens apenas .

Façam o teste trocando esses números.

Código completo

"""
================================
Faces recognition example using eigenfaces and SVMs
================================

An example showing how the scikit-learn can be used to faces recognition with eigenfaces and SVMs

================================
================================

================================
Exemplo de reconhecimento de faces usando autofaces e SVMs
================================

Exemplo mostrando como o scikit-learn pode ser usado para reconhecimento de faces com autofaces e SVMs
"""
from time import time
import logging
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV
from sklearn.datasets import fetch_lfw_people
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
from sklearn.decomposition import PCA
from sklearn.svm import SVC

print(__doc__)

# O logging exibe o progresso da execução no stdout
# adicionando as informações de data e hora
logging.basicConfig(level=logging.INFO, format='%(asctime)s %(message)s')

# #############################################################################
# Download dos dados, se ainda não estiver em disco e carregue-a como uma matriz numpy
lfw_people = fetch_lfw_people(min_faces_per_person=70, resize=0.4)

# Inspeciona as matrizes de imagens para encontrar os formatos das imagens( para plotagem )
n_samples, h, w = lfw_people.images.shape

# para aprendizado de máquina, usamos 2 dados diretamente( esse modelo ignora
# informações relativas a posição do pixel )
X = lfw_people.data
n_features = X.shape[1]

# A rótulo( label ) a prever é o ID da pessoa
y = lfw_people.target
target_names = lfw_people.target_names
n_classes = target_names.shape[0]

print("Total dataset size:")
print(f"n_samples: {n_samples}")
print(f"n_features: {n_features}")
print(f"n_classes: {n_classes}")

# #############################################################################
# Divide a base em um conjunto de treinamento e um conjunto de teste usando k fold
# 25% da base para o conjunto de teste os 75% restantes para o treino
# random_state é para inicializar o gerador interno de números aleatórios
# Definir random_state com um valor fixo garantirá que a mesma sequência de números 
# aleatórios seja gerada cada vez que você executar o código
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42)

# #############################################################################
# Computa o principal component analysis - PCA (eigenfaces) na base de faces 
# ( tratado como dataset não rotulado ): extração não supervisionada / redução de dimensionalidade
n_components = 150
print(f"Extracting the top {n_components} eigenfaces from {X_train.shape[0]} faces")
# t0 guarda o tempo zero, para cálculo do tempo de execução do PCA
# O cálculo é feito no time() - t0 do print da linha 81
t0 = time()
pca = PCA(n_components=n_components, svd_solver='randomized',
          whiten=True).fit(X_train)
print("done in {0:.3f}s".format(time() - t0))

eigenfaces = pca.components_.reshape((n_components, h, w))

print("Projecting the input data on the eigenfaces orthonormal basis")
t0 = time()
X_train_pca = pca.transform(X_train)
X_test_pca = pca.transform(X_test)
print("done in {0:.3f}s".format(time() - t0))

# #############################################################################
# Treinando um modelo de classificação SVM

print("Fitting the classifier to the training set")
t0 = time()
param_grid = {'C': [1e3, 5e3, 1e4, 5e4, 1e5],
              'gamma': [0.0001, 0.0005, 0.001, 0.005, 0.01, 0.1], }
clf = GridSearchCV(SVC(kernel='rbf', class_weight='balanced'), param_grid)
clf = clf.fit(X_train_pca, y_train)
print("done in {0:.3f}s".format(time() - t0))
print("Best estimator found by grid search:")
print(clf.best_estimator_)

# #############################################################################
# Avaliação quantitativa da qualidade do modelo sobre o conjunto de testes

print("Predicting people's names on the test set")
t0 = time()
y_pred = clf.predict(X_test_pca)
print("done in {0:.3f}s".format(time() - t0))

print(classification_report(y_test, y_pred, target_names=target_names))
print(confusion_matrix(y_test, y_pred, labels=range(n_classes)))

# #############################################################################
# Avaliação qualitativa das previsões usando matplotlib

def plot_gallery(images, titles, h, w, n_row=3, n_col=4):
    """Helper function to plot a gallery of portraits"""
    plt.figure(figsize=(1.8 * n_col, 2.4 * n_row))
    plt.subplots_adjust(bottom=0, left=.01, right=.99, top=.90, hspace=.35)
    for i in range(n_row * n_col):
        plt.subplot(n_row, n_col, i + 1)
        plt.imshow(images[i].reshape((h, w)), cmap=plt.cm.gray)
        plt.title(titles[i], size=12)
        plt.xticks(())
        plt.yticks(())

# Plota o resultado da previsão em uma parte do conjunto de testes
def title(y_pred, y_test, target_names, i):
    pred_name = target_names[y_pred[i]].rsplit(' ', 1)[-1]
    true_name = target_names[y_test[i]].rsplit(' ', 1)[-1]
    return f'predicted: {pred_name}\ntrue:      {true_name}'

prediction_titles = [title(y_pred, y_test, target_names, i)
                     for i in range(y_pred.shape[0])]

plot_gallery(X_test, prediction_titles, h, w)

# plota a galeria das autofaces mais significativas
eigenface_titles = [f"eigenface {i}" for i in range(eigenfaces.shape[0])]
plot_gallery(eigenfaces, eigenface_titles, h, w)
# inicia um loop de eventos, procura todos os objetos de figura ativos 
# no momento e abre uma ou mais janelas interativas que exibem sua figura 
# ou figuras
plt.show()

Analisando a parte em laranja do código

Função plot_gallery()

A função plot_gallery recebe as imagens do conjunto de teste, já com PCA, os títulos previstos, a altura e a largura e define que as imagens serão mostradas em 3 linhas e 4 colunas.

Imagens plotadas pela plot_gallery

Depois temos plt.figure e plt.subplots_adjust com alguns parâmetros.

Os parâmetros do plt.figure são para ajuste do tamanho das fotos na plotagem.

E os parâmetros do plt.subplots_adjust definem o espaçamento entre as fotos.

Com o plt.figure criamos uma instância de uma foto usando matplotlib.pyplot.figure (), que é um método conveniente para instanciar Figuras e conectá-las à interface do usuário ou ao FigureCanvas do kit de ferramentas de desenho.

Em seguida temos um loop for no range de número de linhas(3) vezes o número de colunas(4), ou seja, no range(12).

Dentro do loop for da plot_gallery()

Subplot

Em plt.subplot(n_row, n_col, i + 1), os parâmetros indicam o número total de linhas, colunas e o terceiro parâmetro é o índice da figura.

O index começa em 1 no canto superior esquerdo e aumenta para a direita.

O primeiro subplot é a primeira coluna da primeira linha, o segundo subplot é a segunda coluna da primeira linha e assim por diante.

O index começa em 1, por isso o i + 1 em plt.subplot(n_row, n_col, i + 1).

Usando com i apenas, vai dá o seguinte erro:

ValueError: num must be 1 <= num <= 12, not 0

imshow

A função matplotlib imshow() cria uma imagem a partir de uma matriz numpy bidimensional.

A imagem terá um quadrado para cada elemento da matriz.

A cor de cada quadrado é determinada pelo valor do elemento da matriz correspondente e pelo mapa de cores usado por imshow(), no caso do nosso exemplo, o mapa plt.cm.gray.

cmap

O cmap vai mapear os valores numéricos para cada quadrado (pixel) correspondente, referentes as intensidades das cores vermelho, verde e azul entre 0 e 1, se for imagem colorida , ou intensidade de cinza se for preto e branco.

Quando uma imagem tem forma (M,N,3)ou (M,N,4), os valores são interpretados como valores RGB ou RGBA.

Nesse caso, o cmap é ignorado.

No exemplo que estamos trabalhando das imagens de faces, o formato das imagens é uma matriz M X N.

Vamos pegar uma imagem qualquer, a da posição 2 no conjunto de teste pra ver a matriz.

X_test[2].reshape((h, w))

Saída:

array([[ 70. , 111.333336, 128.33333 , …, 130.33333 , 117.666664,
91.666664],
[ 76. , 117.666664, 125.333336, …, 138.66667 , 138.66667 ,
118.666664],
[ 93.666664, 118. , 119. , …, 142. , 150.66667 ,
140.33333 ],
…,
[ 38.333332, 42. , 37. , …, 128.66667 , 168. ,
181.33333 ],
[ 38. , 40. , 37. , …, 145.66667 , 184.66667 ,
175. ],
[ 39.333332, 37.333332, 35. , …, 172.66667 , 185.33333 ,
172. ]], dtype=float32)

Vamos plotar a imagem 2?

plt.imshow(X_test[2].reshape((h, w)), cmap=plt.cm.gray)
plt.show()

Faça testes trocando o índice da foto.

Enfim, voltando, no caso do exemplo que estamos vendo, como temos uma matriz de forma (M,N), o cmap é quem controla o mapa de cores usado para exibir as imagens.

title

A plt.title() define um título para os eixos.

Ela tem um parâmetro plt.title(titles[i], size=12), que se refere ao tamanho da fonte do título.

ticks

xticks() # Obtém as localizações e as etiquetas(labels) do eixo X.

yticks() # Obtém as localizações e as etiquetas(labels) do eixo Y.

Com isso encerramos a análise da função plot_gallery()

Função title()

A linha pred_name = target_names[y_pred[i]].rsplit(‘ ‘, 1)[-1] pega os nomes que o modelo previu.

Já em true_name = target_names[y_test[i]].rsplit(‘ ‘, 1)[-1] pega os nomes corretos.

Para entender melhor as linhas acima, imagine que:

target_names[y_pred[i]] = ‘George W Bush’

Definir o parâmetro maxsplit como 1 no .rsplit(‘ ‘, 1), retornará uma lista com 2 elementos [‘George W’, ‘Bush’].

O primeiro elemento é a string ‘George W’  e o segundo ‘Bush’.

E o [ -1] do .rsplit(‘ ‘, 1)[-1], pega só o último elemento, nesse caso, só o ‘Bush’.

No final a função retorna f’predicted: {pred_name}\ntrue: {true_name}’

Ou seja, uma lista tipo: [‘predicted: Bush\ntrue: Bush’, ‘predicted: Bush\ntrue: Bush’, ‘predicted: Blair\ntrue: Blair’, ‘predicted: Bush\ntrue: Bush’, ‘predicted: Bush\ntrue: Bush’, ‘predicted: Bush\ntrue: Bush’, ‘predicted: Schroeder\ntrue: Schroeder’, ‘predicted: Powell\ntrue: Powell’, ‘predicted: Bush\ntrue: Bush’, ‘predicted: Bush\ntrue: Bush’, ‘predicted: Bush\ntrue: Bush’, ‘predicted: Bush\ntrue: Bush’, ‘predicted: Bush\ntrue: Bush’, ‘predicted: Bush\ntrue: Blair’, ‘predicted: Bush\ntrue: Bush’, ‘predicted: Bush\ntrue: Bush’, ‘predicted: Bush\ntrue: Bush’, ‘predicted: Bush\ntrue: Bush’, ‘predicted: Bush\ntrue: Bush’, ‘predicted: Schroeder\ntrue: Schroeder’, ‘predicted: Powell\ntrue: Powell’…]

Aqui encerramos a análise da title()

Chamadas da title()

Agora temos a linha:

prediction_titles = [title(y_pred, y_test, target_names, i) for i in range(y_pred.shape[0])]

Foi usado List Comprehension, para preencher o prediction_title.

O target_names são nossas classes alvo:

[‘Ariel Sharon’, ‘Colin Powell’, ‘Donald Rumsfeld’, ‘George W Bush’,’Gerhard Schroeder’, ‘Hugo Chavez’, ‘Tony Blair’]

O y_pred são os valores que o modelo previu na hora que fizemos a avaliação quantitativa.

O y_test são os valores corretos para que possamos avaliar nosso classificador e saber se ele tá acertando, ou o quanto ele tá acertando e o quanto tá errando.

Primeira chamada da plot_gallery()

Em seguida temos a primeira chamada da nossa plot_gallery(X_test, prediction_titles, h, w).

Para ela será passado o X_test, que é a parte da base em que o classificador não foi treinado, portanto, o classificador não conhece esses dados.

O prediction_titles guarda a lista retornada pela função title(), mostrada parcialmente acima em verde.

O h (altura) e o w (largura) foram pegos logo no início do código em:

n_samples, h, w = lfw_people.images.shape

Segunda chamada da plot_gallery()

Antes da segunda chamada temos: eigenface_titles = [f”eigenface {i}” for i in range(eigenfaces.shape[0])]

Essa linha vai colocar em cada imagem: eigenface 0, eigenface 1, eigenface 2 …

Em seguida a segunda chamada da plot_gallery() passando: a eigenfaces (que foi resultado do PCA), eigenface_titles (resultado da linha anterior), a altura(h) e a largura(w).

plt.show()

Por fim, plt.show(), ela inicia um loop de eventos, procura todos os objetos de figura ativos no momento e abre uma ou mais janelas interativas que exibem sua figura ou figuras.

Ficamos por aqui, com essa aula encerramos a explicação do código:

https://scikit-learn.org/stable/auto_examples/applications/plot_face_recognition.html

Voltar para página principal do blog

Todas as aulas desse curso

Aula 16              Aula 18

Link do meu Github com o script dessa aula:

Download do script da aula

Se gostarem do conteúdo dêem um joinha na página do Código Fluente no
Facebook

Link do código fluente no Pinterest

Novamente deixo meus link de afiliados:

Hostinger

Digital Ocean

One.com

Obrigado, até a próxima e bons estudos.