O TensorFlow é uma ferramenta versátil para criar modelos de aprendizado de máquina.
Nesta postagem, veremos como criar um sistema de reconhecimento facial com o TensorFlow, uma estrutura de aprendizado de máquina de código aberto. Examinaremos os processos essenciais na criação de um sistema de reconhecimento facial bem-sucedido, desde a coleta e preparação de dados até o treinamento e avaliação de um modelo.
Você terá experiência em primeira mão com o TensorFlow para criar reconhecimento facial com a ajuda de trechos de código e exemplos do mundo real. Você está convidado a acompanhar enquanto prosseguimos.
Introdução ao TensorFlow
TensorFlow é uma biblioteca gratuita e de código aberto. É uma caixa de ferramentas matemática simbólica que usa fluxo de dados e programação diferenciável. Você pode lidar com uma variedade de tarefas com ele, incluindo profunda rede neural treinamento.
O TensorFlow é poderoso e adaptável. Da mesma forma, é uma ótima ferramenta para desenvolver e implantando modelos de aprendizado de máquina. Você pode construir modelos complicados com várias camadas e operações de tensor. Além disso, modelos pré-construídos na biblioteca podem ser ajustados para necessidades específicas.
Além disso, o TensorFlow tem uma comunidade de usuários enorme e em expansão. Portanto, há uma infinidade de informações e ajuda para quem é novo na plataforma.
TensorFlow é popular para aprendizado de máquina em parte porque fornece um fluxo de trabalho de ponta a ponta. Assim, você pode facilmente construir, treinar e implantar modelos. Ele fornece ferramentas e estratégias para melhorar e dimensionar modelos para atender a demandas específicas. Varia desde o pré-processamento de dados até a implantação do modelo.
O que é reconhecimento facial?
O reconhecimento facial é um visão computacional tarefa que identifica a identificação de uma pessoa com base em seu rosto. Essa técnica reconhece traços faciais, como formato e textura dos olhos, nariz e boca.
E os compara a um banco de dados de rostos conhecidos para identificar uma correspondência. O reconhecimento facial tem vários usos, incluindo sistemas de segurança, organização de fotos e autenticação biométrica.
A precisão dos algoritmos de reconhecimento facial aumentou substancialmente nos últimos anos como resultado de avanços no aprendizado de máquina.
Importando Bibliotecas Necessárias
Antes de começar qualquer coisa, precisamos importar as bibliotecas necessárias para o nosso modelo. Tensorflow (tf) é importado e utilizado para criar e treinar o modelo. <(p>
“numpy” realiza cálculos matemáticos e processamento de dados.
“matplotlib.pyplot” é importado como plt e usado para gráficos de dados e visualizações.
Finalmente, “fetch lfw people” é importado do sklearn. conjuntos de dados e usados para carregar o conjunto de dados de reconhecimento facial. Essa função faz parte do kit de ferramentas scikit-learn. Graças a esta função, não precisamos carregar outro conjunto de dados. Isso já está embutido no sckit-learn.
E, dá-lhe acesso a uma ampla gama de conjuntos de dados para aprendizado de máquina formulários. Neste cenário, usamos o método fetch lfw people para recuperar o conjunto de dados “Labeled Faces in the Wild” (LFW). Inclui fotos de rostos de pessoas, bem como os rótulos que os acompanham.
Essas bibliotecas são críticas na implementação e avaliação do nosso modelo de reconhecimento facial.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
Pré-processamento e carregamento do conjunto de dados de reconhecimento facial
Nesta parte, utilizamos a função “fetch lfw people” para pré-processar os dados de reconhecimento facial. Primeiro, usamos fetch lfw people com a opção “min faces per person=60”. Isso indica que queremos incluir apenas pessoas no conjunto de dados que tenham pelo menos 60 fotos. Portanto, garantimos que nosso modelo tenha dados adequados para aprender. Além disso, isso reduz o perigo de overfitting.
Os dados e rótulos do objeto faces são então extraídos e atribuídos às variáveis X e y. X hol.
Agora estamos prontos para treinar nosso modelo de reconhecimento facial usando rótulos e dados pré-processados.
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
Dividindo conjuntos de treinamento e teste
Nesta etapa, dividimos nosso conjunto de dados de reconhecimento facial em duas metades usando o método de divisão de teste de trem da seleção sklearn.model. O objetivo desta divisão é avaliar o desempenho do nosso modelo após o treinamento
A função de divisão de teste de trem aceita como entrada dados X e rótulos y. E os divide em conjuntos de treinamento e teste. Selecionamos test size=0.2 neste exemplo. Isso implica que 20% dos dados serão utilizados como conjunto de teste e 80% como conjunto de treinamento. Além disso, usamos random state=42 para garantir que os dados sejam divididos consistentemente cada vez que o código é executado.
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
Preparando os dados
O objetivo do pré-processamento dos dados é prepará-los para entrada no modelo. Os dados são pré-processados neste código dividindo cada ponto de dados por 255.
O que nos motivou a conseguir isso? A normalização é um procedimento de pré-processamento usado no aprendizado de máquina para garantir que todos os recursos estejam na mesma escala. Nesse cenário, a divisão por 255 dimensiona os dados para um intervalo de 0 a 1, que é uma etapa normal de normalização de dados de imagem.
Isso acelera a convergência do modelo e pode aumentar seu desempenho.
X_train = X_train / 255.0
X_test = X_test / 255.0
Criando o modo
Queremos identificar o indivíduo cujo rosto aparece em uma foto. Nesse caso, usaremos uma rede totalmente conectada, geralmente conhecida como rede densa. É uma rede neural artificial que foi usada para criar o modelo.
As redes neurais artificiais são modeladas de acordo com a forma como o cérebro humano opera e é organizado. Eles são compostos de nós de processamento de informações ou neurônios que estão ligados. Cada neurônio em uma camada em uma rede densa está ligado a cada neurônio na camada acima dela.
O modelo tem quatro camadas neste código. Para alimentar a próxima camada, os dados de entrada são achatados na primeira camada em uma matriz unidimensional. Os neurônios 128 e 64 nas duas camadas seguintes, portanto, estão completamente ligados.
A função de ativação ReLU é uma função de ativação exclusiva usada por essas camadas. Com isso, podemos fazer com que o modelo aprenda correlações não lineares entre as entradas e saídas. A última camada emprega a função de ativação softmax para fazer previsões. E é uma camada totalmente conectada com tantos neurônios quanto classes potenciais.
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(62 * 47,)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(len(target_names), activation='softmax')
])
Compilação do Modelo
O modelo é compilado usando a função “compile”. Precisamos preparar o modelo para o treinamento. Assim, definiremos o otimizador, a função de perda e as métricas que serão utilizadas para avaliar o modelo.
Durante o treinamento, o otimizador se encarrega de alterar os parâmetros do modelo. O otimizador “adam” é uma técnica popular de otimização de aprendizado profundo.
Usamos a função de perda para avaliar o desempenho do modelo nos dados de treinamento. Como os rótulos de destino são inteiros refletindo a classe da imagem em vez de vetores codificados one-hot, a função de perda de “entropia categórica esparsa” é favorável.
Por fim, definimos as métricas para avaliar o modelo, neste caso, “precisão”.
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
Treinamento de modelo
Usaremos a função “fit” para treinar o modelo.
Estaremos fornecendo os dados de treinamento (treinamento X) e rótulos relacionados (treinamento y), bem como definindo o número de épocas (iterações) para executar como 10. O procedimento de treinamento modifica os pesos do modelo para reduzir uma perda (a diferença entre rótulos previstos e reais) e melhoram a precisão dos dados de treinamento.
model.fit(X_train, y_train, epochs=10)
Avaliação de modelo
Agora, precisamos avaliar o modelo treinado nos dados de teste. Usamos a perda de teste e a precisão do teste para avaliar o desempenho do modelo. Nos dados de teste X test e nos rótulos de teste y test, precisamos chamar “a função model.evaluate”
A função gera a precisão do teste e a perda do teste. As variáveis perda de teste e precisão de teste, respectivamente, contêm esses valores. Por fim, usamos a função “print” para gerar a precisão do teste.
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
Prevendo aulas e obtendo as aulas previstas
Usando o modelo de treinamento e os dados de teste, o algoritmo faz previsões. Quando os dados de teste são passados para o método “model.predict”, ele gera uma matriz de previsões para cada imagem no conjunto de teste.
O nome da classe de destino para cada imagem é então recuperado da lista de “nomes de destino” usando a função “np.argmax” para identificar o índice com a maior probabilidade prevista. Este índice é então usado para determinar a classe prevista para cada imagem.
Usando uma compreensão de lista, todas as predições na matriz “predições” são submetidas a esse método, resultando na lista “classes preditas”.
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
Visualizando as previsões
Agora podemos ver como nosso modelo se parece.
Para avaliar o desempenho do modelo, serão mostradas as primeiras 10 fotos e suas previsões. Ele plotará as fotos em escala de cinza e exibirá a classe real da imagem e a classe prevista pelo modelo usando o módulo matplotlib.pyplot.
A função “imshow” é usada pelo loop for para plotar cada uma das 10 primeiras fotos do conjunto de teste. Nomes de destino[y test[i]] e classes previstas[i] são usados para determinar a classe real e a classe prevista da imagem, respectivamente. Os títulos de cada parcela são então indicados por essas classificações.
Por fim, o gráfico é exibido usando o método plt.show().
for i in range(10):
plt.imshow(X_test[i].reshape(62, 47), cmap='gray')
plt.title(f"True: {target_names[y_test[i]]}, Predicted:{predicted_classes[i]}")
plt.show()
Embrulhar
O TensorFlow oferece um ambiente completo e flexível para criar modelos de machine learning.
Ajustando o modelo para atender a requisitos específicos ou adicionando novos desenvolvimentos no aprendizado de máquina, a precisão do modelo pode ser aumentada ainda mais.
O TensorFlow e o reconhecimento facial provavelmente serão usados cada vez mais em setores como sistemas de segurança, autenticação biométrica e assistência médica no futuro. Em breve veremos inovações fascinantes.
Deixe um comentário