Tutorial Keras
Evelyn Clarke
O que é Keras:
Keras é uma biblioteca de rede neural de código aberto escrita em Python que roda em cima de Theano ou Tensorflow. Ele foi projetado para ser modular, rápido e fácil de usar. Foi desenvolvido por François Chollet, engenheiro do Google. Keras não lida com computação de baixo nível. Em vez disso, ele usa outra biblioteca para fazer isso, chamada “Backend.
Keras é um wrapper de API de alto nível para API de baixo nível, capaz de ser executado em TensorFlow, CNTK ou Theano. A API Keras de alto nível lida com a maneira como criamos modelos, definimos camadas ou configuramos vários modelos de entrada-saída. Neste nível, Keras também compila nosso modelo com funções de perda e otimizador, processo de treinamento com função de ajuste. Keras em Python não lida com API de baixo nível, como fazer o gráfico computacional, fazer tensores ou outras variáveis, porque foi tratado pelo mecanismo de “backend”.
O que é um back-end?
Backend é um termo em Keras que executa todos os cálculos de baixo nível, como produtos tensores, convoluções e muitas outras coisas, com a ajuda de outras bibliotecas, como Tensorflow ou Theano. Assim, o “motor backend” realizará a computação e desenvolvimento dos modelos. Tensorflow é o “mecanismo de backend” padrão, mas podemos alterá-lo na configuração.
Back-end Theano, Tensorflow e CNTK
Theano é um projeto de código aberto desenvolvido pelo grupo MILA da Universidade de Montreal, Quebec, Canadá. Foi o primeiro Framework amplamente utilizado. É um Python biblioteca que ajuda em matrizes multidimensionais para operações matemáticas usando Numpy ou Scipy. Theano pode usar GPUs para computação mais rápida, ele também pode construir automaticamente gráficos simbólicos para computação de gradientes. Em seu site, Theano afirma que pode reconhecer expressões numericamente instáveis e computá-las com algoritmos mais estáveis, isso é muito útil para nossas expressões instáveis.
Por outro lado, o Tensorflow é a estrela em ascensão na estrutura de aprendizagem profunda. Desenvolvido pela equipe Brain do Google, é a ferramenta de aprendizado profundo mais popular. Com muitos recursos, os pesquisadores contribuem para ajudar a desenvolver esta estrutura para fins de aprendizagem profunda.
Outro mecanismo de back-end para Keras é o Microsoft Kit de ferramentas cognitivas ou CNTK. É uma estrutura de aprendizagem profunda de código aberto desenvolvida por Microsoft Equipe. Ele pode ser executado em várias GPUs ou em várias máquinas para treinar o modelo de aprendizado profundo em grande escala. Em alguns casos, o CNTK foi relatado mais rapidamente do que outras estruturas, como Tensorflow ou Theano. A seguir neste tutorial Keras CNN, compararemos os backends de Theano, TensorFlow e CNTK.
Comparando os back-ends
Precisamos fazer um benchmark para saber a comparação entre esses dois backends. Como você pode ver em Referência de Jeong-Yoon Lee, o desempenho de três back-ends diferentes em hardwares diferentes é comparado. E o resultado é que Theano é mais lento que o outro backend, é relatado vezes 50 mais lento, mas a precisão está próxima uma da outra.
Outro teste de referência é realizado por Jasmeet Bhatia. Ele relatou que Theano é mais lento que o Tensorflow em alguns testes. Mas a precisão geral é quase a mesma para todas as redes testadas.
Então, entre Theano, Tensorflow e CTK é óbvio que TensorFlow é melhor que Theano. Com o TensorFlow, o tempo de cálculo é muito menor e o CNN é melhor que os outros.
Próximo neste Keras Python tutorial, aprenderemos sobre a diferença entre Keras e TensorFlow (Keras x Tensorflow).
Keras x Tensorflow
| Parâmetros Técnicos | Keras | Tensorflow |
|---|---|---|
| Formato | Wrapper de API de alto nível | API de baixo nível |
| Complexidade | Fácil de usar se você Python língua | Você precisa aprender a sintaxe de uso de algumas funções do Tensorflow |
| Propósito | Implantação rápida para criar modelos com camadas padrão | Permite que você crie um gráfico computacional arbitrário ou camadas de modelo |
| Ferramentas | Usa outra ferramenta de depuração de API, como TFDBG | Você pode usar ferramentas de visualização do Tensorboard |
| Comunidade | Grandes comunidades ativas | Grandes comunidades ativas e recursos amplamente compartilhados |
Vantagens do Keras
Implantação rápida e fácil de entender
Keras é muito rápido para criar um modelo de rede. Se você quiser fazer um modelo de rede simples com poucas linhas, Python Keras pode ajudá-lo com isso. Veja o exemplo de Keras abaixo:
from keras.models import Sequential from keras.layers import Dense, Activation model = Sequential() model.add(Dense(64, activation='relu', input_dim=50)) #input shape of 50 model.add(Dense(28, activation='relu')) #input shape of 50 model.add(Dense(10, activation='softmax'))
Por causa da API amigável, podemos entender facilmente o processo. Escrever o código com uma função simples e sem necessidade de definir vários parâmetros.
Apoio de grande comunidade
Existem muitas comunidades de IA que usam Keras para sua estrutura de Deep Learning. Muitos deles publicam seus códigos e também tutoriais para o público em geral.
Tenha vários back-ends
Você pode escolher Tensorflow, CNTK e Theano como back-end com Keras. Você pode escolher um back-end diferente para projetos diferentes, dependendo de suas necessidades. Cada back-end tem sua própria vantagem exclusiva.
Implantação fácil e multiplataforma de modelo
Com uma variedade de dispositivos e plataformas compatíveis, você pode implantar o Keras em qualquer dispositivo, como
- iOS com CoreML
- Android com Tensorflow Android,
- Navegador da Web com suporte .js
- Mecanismo de nuvem
- Raspberry Pi
Suporte a múltiplas GPUs
Você pode treinar Keras em uma única GPU ou usar várias GPUs ao mesmo tempo. Porque Keras tem suporte integrado para paralelismo de dados para que possa processar grandes volumes de dados e acelerar o tempo necessário para treiná-los.
Desvantagens de Keras
Não é possível lidar com API de baixo nível
Keras lida apenas com APIs de alto nível que são executadas em outra estrutura ou mecanismo de back-end, como Tensorflow, Theano ou CNTK. Portanto, não é muito útil se você deseja criar sua própria camada abstrata para fins de pesquisa, porque o Keras já possui camadas pré-configuradas.
Instalando Keras
Nesta seção, veremos vários métodos disponíveis para instalar o Keras
Instalação direta ou ambiente virtual
Qual é o melhor? Instalação direta no python atual ou uso de um ambiente virtual? Sugiro usar um ambiente virtual se você tiver muitos projetos. Quer saber por quê? Isso ocorre porque diferentes projetos podem usar uma versão diferente de uma biblioteca keras.
Por exemplo, tenho um projeto que precisa Python 3.5 usando OpenCV 3.3 com backend Keras-Theano mais antigo, mas no outro projeto eu tenho que usar Keras com a versão mais recente e um Tensorflow como backend com Python Apoio 3.6.6
Não queremos que a biblioteca Keras entre em conflito, certo? Então usamos um Ambiente Virtual para localizar o projeto com um tipo específico de biblioteca ou podemos usar outra plataforma como Cloud Service para fazer nossos cálculos para nós como Amazon Serviço de internet.
Instalando Keras em Amazon Serviço Web (AWS)
Amazon Web Service é uma plataforma que oferece serviços e produtos de Cloud Computing para pesquisadores ou quaisquer outros fins. A AWS aluga seu hardware, rede, banco de dados, etc. para que possamos usá-lo diretamente da internet. Um dos serviços populares da AWS para fins de aprendizagem profunda é o Amazon Serviço de aprendizado profundo de imagem de máquina ou DL
Para obter instruções detalhadas sobre como usar a AWS, consulte este tutorial
Nota sobre a AMI: você terá a seguinte AMI disponível
AWS Deep Learning AMI é um ambiente virtual no AWS EC2 Service que ajuda pesquisadores ou profissionais a trabalhar com Deep Learning. DLAMI oferece desde mecanismos de CPUs pequenas até mecanismos multi GPUs de alta potência com CUDA, cuDNN pré-configurados e vem com uma variedade de estruturas de aprendizado profundo.
Se quiser usá-lo instantaneamente, você deve escolher Deep Learning AMI porque ele vem pré-instalado com estruturas populares de aprendizado profundo.
Mas se você quiser experimentar uma estrutura de aprendizado profundo personalizada para pesquisa, você deve instalar o Deep Learning Base AMI porque ele vem com bibliotecas fundamentais como CUDA, cuDNN, drivers de GPU e outras bibliotecas necessárias para funcionar com seu ambiente de aprendizado profundo.
Como instalar o Keras em Amazon SageMaker
Amazon SageMaker é uma plataforma de aprendizado profundo para ajudá-lo a treinar e implantar rede de aprendizado profundo com o melhor algoritmo.
Para um iniciante, este é de longe o método mais fácil de usar o Keras. Abaixo está um processo sobre como instalar Keras em Amazon Criador de Sábio:
Etapa 1) Abrir Amazon SageMaker
Na primeira etapa, abra o Amazon Sábio console e clique em Criar instância de notebook.
Etapa 2) Insira os detalhes
- Digite o nome do seu bloco de notas.
- Crie uma função do IAM. Isso criará uma função AMI Amazon Função IAM no formato de AmazonSageMaker-Executionrole-AAAAMMDD|HHmmSS.
- Por fim, escolha Criar instância de notebook. Depois de alguns momentos, Amazon Sagemaker lança uma instância de notebook.
Observação: se desejar acessar recursos da sua VPC, defina o acesso direto à Internet como ativado. Caso contrário, esta instância de notebook não terá acesso à Internet, sendo impossível treinar ou hospedar modelos
Etapa 3) Inicie a instância
Clique em Abrir para iniciar a instância
Etapa 4) Comece a codificar
In Jupyter, Clique em Novo> conda_tensorflow_p36 e você está pronto para codificar
Instale Keras no Linux
Para habilitar Keras com Tensorflow como mecanismo de back-end, precisamos primeiro instalar o Tensorflow. Execute este comando para instalar o tensorflow com CPU (sem GPU)
pip install --upgrade tensorflow
se você deseja habilitar o suporte de GPU para tensorflow você pode usar este comando
pip install --upgrade tensorflow-gpu
vamos fazer o check-in Python para ver se nossa instalação foi bem-sucedida digitando
user@user:~$ python Python 3.6.4 (default, Mar 20 2018, 11:10:20) [GCC 5.4.0 20160609] on linux Type "help", "copyright", "credits" or "license" for more information. >>> import tensorflow >>>
se não houver mensagem de erro, o processo de instalação foi bem-sucedido
Instale Keras
Depois de instalar o Tensorflow, vamos começar a instalar o keras. Digite este comando no terminal
pip install keras
ele começará a instalar o Keras e também todas as suas dependências. Você deverá ver algo assim:
Agora temos Keras instalado em nosso sistema!
Verificando
Antes de começarmos a usar Keras, devemos verificar se nosso Keras usa Tensorflow como backend abrindo o arquivo de configuração:
gedit ~/.keras/keras.json
você deve ver algo assim
{
"floatx": "float32",
"epsilon": 1e-07,
"backend": "tensorflow",
"image_data_format": "channels_last"
}
como você pode ver, o “backend” usa tensorflow. Isso significa que Keras está usando o Tensorflow como back-end, conforme esperávamos
e agora execute-o no terminal digitando
user@user:~$ python3 Python 3.6.4 (default, Mar 20 2018, 11:10:20) [GCC 5.4.0 20160609] on linux Type "help", "copyright", "credits" or "license" for more information. >>> import keras Using TensorFlow backend. >>>
Como instalar o Keras em Windows
Antes de instalarmos Tensorflow e Keras, devemos instalar Python, pip e virtualenv. Se você já instalou essas bibliotecas, você deve continuar para o próximo passo, caso contrário, faça isto:
Instale Python 3 baixando deste link
Instale o pip executando esse
Instale o virtualenv com este comando
pip3 install –U pip virtualenv
Instale Microsoft visual C++ Atualização Redistribuível 2015 de 3
- Acesse o site de download do Visual Studio https://www.microsoft.com/en-us/download/details.aspx?id=53587
- Selecione redistribuíveis e ferramentas de construção
- Baixe e instale o Microsoft visual C++ Atualização Redistribuível 2015 de 3
Então execute este script
pip3 install virtualenv
Configurar ambiente virtual
Isso é usado para isolar o sistema em funcionamento do sistema principal.
virtualenv –-system-site-packages –p python3 ./venv
Ative o ambiente
.\venv\Scripts\activate
Depois de preparar o ambiente, a instalação do Tensorflow e Keras permanece igual ao Linux. A seguir neste tutorial de aprendizado profundo com Keras, aprenderemos sobre os fundamentos do Keras para aprendizado profundo.
Fundamentos de Keras para aprendizado profundo
A estrutura principal do Keras é o Modelo que define o gráfico completo de uma rede. Você pode adicionar mais camadas a um modelo existente para construir um modelo personalizado necessário para o seu projeto.
Veja como fazer um modelo sequencial e algumas camadas comumente usadas em aprendizado profundo
1. Modelo Sequencial
from keras.models import Sequential from keras.layers import Dense, Activation,Conv2D,MaxPooling2D,Flatten,Dropout model = Sequential()
2. Camada Convolucional
Este é um Keras Python exemplo de camada convolucional como camada de entrada com formato de entrada 320x320x3, com 48 filtros de tamanho 3×3 e usa ReLU como função de ativação.
input_shape=(320,320,3) #this is the input shape of an image 320x320x3 model.add(Conv2D(48, (3, 3), activation='relu', input_shape= input_shape))
outro tipo é
model.add(Conv2D(48, (3, 3), activation='relu'))
3. MáxPooling Camada
Para reduzir a resolução da representação de entrada, use MaxPool2d e especifique o tamanho do kernel
model.add(MaxPooling2D(pool_size=(2, 2)))
4. Camada Densa
adicionando uma camada totalmente conectada apenas especificando o tamanho da saída
model.add(Dense(256, activation='relu'))
5. Camada de exclusão
Adicionando camada de eliminação com 50% de probabilidade
model.add(Dropout(0.5))
Compilar, treinar e avaliar
Depois de definirmos nosso modelo, vamos começar a treiná-los. É necessário compilar a rede primeiro com a função de perda e a função de otimizador. Isso permitirá que a rede altere os pesos e minimize a perda.
model.compile(loss='mean_squared_error', optimizer='adam')
Agora, para iniciar o treinamento, use fit para alimentar o modelo com os dados de treinamento e validação. Isso permitirá que você treine a rede em lotes e defina as épocas.
model.fit(X_train, X_train, batch_size=32, epochs=10, validation_data=(x_val, y_val))
Nossa etapa final é avaliar o modelo com os dados de teste.
score = model.evaluate(x_test, y_test, batch_size=32)
Vamos tentar usar regressão linear simples
import keras
from keras.models import Sequential
from keras.layers import Dense, Activation
import numpy as np
import matplotlib.pyplot as plt
x = data = np.linspace(1,2,200)
y = x*4 + np.random.randn(*x.shape) * 0.3
model = Sequential()
model.add(Dense(1, input_dim=1, activation='linear'))
model.compile(optimizer='sgd', loss='mse', metrics=['mse'])
weights = model.layers[0].get_weights()
w_init = weights[0][0][0]
b_init = weights[1][0]
print('Linear regression model is initialized with weights w: %.2f, b: %.2f' % (w_init, b_init))
model.fit(x,y, batch_size=1, epochs=30, shuffle=False)
weights = model.layers[0].get_weights()
w_final = weights[0][0][0]
b_final = weights[1][0]
print('Linear regression model is trained to have weight w: %.2f, b: %.2f' % (w_final, b_final))
predict = model.predict(data)
plt.plot(data, predict, 'b', data , y, 'k.')
plt.show()
Depois de treinar os dados, a saída deve ficar assim
com o peso inicial
Linear regression model is initialized with weights w: 0.37, b: 0.00
e peso final
Linear regression model is trained to have weight w: 3.70, b: 0.61
Ajuste fino de modelos pré-treinados em Keras e como usá-los
Por que usamos modelos Fine Tune e quando os usamos
O ajuste fino é uma tarefa para ajustar um modelo pré-treinado de forma que os parâmetros se adaptem ao novo modelo. Quando queremos treinar do zero em um novo modelo, precisamos de uma grande quantidade de dados, para que a rede consiga encontrar todos os parâmetros. Mas neste caso usaremos um modelo pré-treinado para que os parâmetros já sejam aprendidos e tenham peso.
Por exemplo, se quisermos treinar nosso próprio modelo Keras para resolver um problema de classificação, mas tivermos apenas uma pequena quantidade de dados, podemos resolver isso usando um Aprendizagem por transferência + Método de ajuste fino.
Usando uma rede e pesos pré-treinados, não precisamos treinar toda a rede. Precisamos apenas treinar a última camada usada para resolver nossa tarefa, pois o chamamos de método de ajuste fino.
Preparação do modelo de rede
Para o modelo pré-treinado, podemos carregar uma variedade de modelos que Keras já possui em sua biblioteca, como:
- VGG16
- Inception V3
- ResNet
- MobileNet
- Xception
- InícioResNetV2
Mas neste processo usaremos o modelo de rede VGG16 e o imageNet como nosso peso para o modelo. Ajustaremos uma rede para classificar 8 tipos diferentes de classes usando imagens de Conjunto de dados de imagens naturais Kaggle
Arquitetura do modelo VGG16
Carregando nossos dados para o AWS S3 Bucket
Para o nosso processo de treinamento, usaremos uma imagem de imagens naturais de 8 classes diferentes, como aviões, carro, gato, cachorro, flor, fruta, motocicleta e pessoa. Primeiro, precisamos enviar nossos dados para Amazon Balde S3.
Amazon Balde S3
Passo 1) Após fazer login em sua conta S3, vamos criar um bucket cronometrando Criar Bucket
Passo 2) Agora escolha um nome de bucket e sua região de acordo com sua conta. Certifique-se de que o nome do bucket esteja disponível. Depois disso clique Criar.
Passo 3) Como você pode ver, seu balde está pronto para uso. Mas como você pode ver, o acesso não é público, é bom para você se quiser mantê-lo privado. Você pode alterar este bucket para acesso público nas propriedades do bucket
Passo 4) Agora você começa a enviar seus dados de treinamento para o seu Bucket. Aqui farei upload do arquivo tar.gz que consiste em fotos para treinamento e processo de teste.
Passo 5) Agora clique no seu arquivo e copie o de vidrio para que possamos baixá-lo.
Preparação de dados
Precisamos gerar nossos dados de treinamento usando Keras ImageDataGenerator.
Primeiro você deve fazer o download usando o wget com o link para o seu arquivo do S3 Bucket.
!wget https://s3.us-east-2.amazonaws.com/naturalimages02/images.tar.gz !tar -xzf images.tar.gz
Após baixar os dados vamos iniciar o Processo de Treinamento.
from keras.preprocessing.image import ImageDataGenerator
import numpy as np
import matplotlib.pyplot as plt
train_path = 'images/train/'
test_path = 'images/test/'
batch_size = 16
image_size = 224
num_class = 8
train_datagen = ImageDataGenerator(validation_split=0.3,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
train_generator = train_datagen.flow_from_directory(
directory=train_path,
target_size=(image_size,image_size),
batch_size=batch_size,
class_mode='categorical',
color_mode='rgb',
shuffle=True)
Os dados da imagemGenerator criará dados X_training de um diretório. O subdiretório nesse diretório será usado como uma classe para cada objeto. A imagem será carregada com o modo de cor RGB, com o modo de classe categórica para os dados Y_training, com tamanho de lote 16. Por fim, embaralhe os dados.
Vamos ver nossas imagens aleatoriamente plotando-as com matplotlib
x_batch, y_batch = train_generator.next()
fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows):
num = np.random.randint(batch_size)
image = x_batch[num].astype(np.int)
fig.add_subplot(rows, columns, i)
plt.imshow(image)
plt.show()
Depois disso vamos criar nosso modelo de rede a partir de VGG16 com peso pré-treinado imageNet. Congelaremos essas camadas para que não sejam treináveis para nos ajudar a reduzir o tempo de computação.
Criando nosso modelo a partir de VGG16
import keras
from keras.models import Model, load_model
from keras.layers import Activation, Dropout, Flatten, Dense
from keras.preprocessing.image import ImageDataGenerator
from keras.applications.vgg16 import VGG16
#Load the VGG model
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(image_size, image_size, 3))
print(base_model.summary())
# Freeze the layers
for layer in base_model.layers:
layer.trainable = False
# # Create the model
model = keras.models.Sequential()
# # Add the vgg convolutional base model
model.add(base_model)
# # Add new layers
model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dense(1024, activation='relu'))
model.add(Dense(num_class, activation='softmax'))
# # Show a summary of the model. Check the number of trainable parameters
print(model.summary())
Como você pode ver abaixo, o resumo do nosso modelo de rede. A partir de uma entrada das camadas VGG16, adicionamos 2 camadas totalmente conectadas que extrairão 1024 recursos e uma camada de saída que calculará as 8 classes com a ativação do softmax.
Layer (type) Output Shape Param # ================================================================= vgg16 (Model) (None, 7, 7, 512) 14714688 _________________________________________________________________ flatten_1 (Flatten) (None, 25088) 0 _________________________________________________________________ dense_1 (Dense) (None, 1024) 25691136 _________________________________________________________________ dense_2 (Dense) (None, 1024) 1049600 _________________________________________________________________ dense_3 (Dense) (None, 8) 8200 ================================================================= Total params: 41,463,624 Trainable params: 26,748,936 Non-trainable params: 14,714,688
Formação
# # Compile the model
from keras.optimizers import SGD
model.compile(loss='categorical_crossentropy',
optimizer=SGD(lr=1e-3),
metrics=['accuracy'])
# # Start the training process
# model.fit(x_train, y_train, validation_split=0.30, batch_size=32, epochs=50, verbose=2)
# # #save the model
# model.save('catdog.h5')
history = model.fit_generator(
train_generator,
steps_per_epoch=train_generator.n/batch_size,
epochs=10)
model.save('fine_tune.h5')
# summarize history for accuracy
import matplotlib.pyplot as plt
plt.plot(history.history['loss'])
plt.title('loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['loss'], loc='upper left')
plt.show()
Resultados
Epoch 1/10 432/431 [==============================] - 53s 123ms/step - loss: 0.5524 - acc: 0.9474 Epoch 2/10 432/431 [==============================] - 52s 119ms/step - loss: 0.1571 - acc: 0.9831 Epoch 3/10 432/431 [==============================] - 51s 119ms/step - loss: 0.1087 - acc: 0.9871 Epoch 4/10 432/431 [==============================] - 51s 119ms/step - loss: 0.0624 - acc: 0.9926 Epoch 5/10 432/431 [==============================] - 51s 119ms/step - loss: 0.0591 - acc: 0.9938 Epoch 6/10 432/431 [==============================] - 51s 119ms/step - loss: 0.0498 - acc: 0.9936 Epoch 7/10 432/431 [==============================] - 51s 119ms/step - loss: 0.0403 - acc: 0.9958 Epoch 8/10 432/431 [==============================] - 51s 119ms/step - loss: 0.0248 - acc: 0.9959 Epoch 9/10 432/431 [==============================] - 51s 119ms/step - loss: 0.0466 - acc: 0.9942 Epoch 10/10 432/431 [==============================] - 52s 120ms/step - loss: 0.0338 - acc: 0.9947
Como você pode ver, nossas perdas diminuíram significativamente e a precisão é de quase 100%. Para testar nosso modelo, escolhemos imagens aleatoriamente na internet e colocamos na pasta de testes com uma classe diferente para testar
Testando nosso modelo
model = load_model('fine_tune.h5')
test_datagen = ImageDataGenerator()
train_generator = train_datagen.flow_from_directory(
directory=train_path,
target_size=(image_size,image_size),
batch_size=batch_size,
class_mode='categorical',
color_mode='rgb',
shuffle=True)
test_generator = test_datagen.flow_from_directory(
directory=test_path,
target_size=(image_size, image_size),
color_mode='rgb',
shuffle=False,
class_mode='categorical',
batch_size=1)
filenames = test_generator.filenames
nb_samples = len(filenames)
fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows -1):
x_batch, y_batch = test_generator.next()
name = model.predict(x_batch)
name = np.argmax(name, axis=-1)
true_name = y_batch
true_name = np.argmax(true_name, axis=-1)
label_map = (test_generator.class_indices)
label_map = dict((v,k) for k,v in label_map.items()) #flip k,v
predictions = [label_map[k] for k in name]
true_value = [label_map[k] for k in true_name]
image = x_batch[0].astype(np.int)
fig.add_subplot(rows, columns, i)
plt.title(str(predictions[0]) + ':' + str(true_value[0]))
plt.imshow(image)
plt.show()
E nosso teste é o mostrado abaixo! Apenas 1 imagem está errada em um teste de 14 imagens!
Rede Neural de Reconhecimento Facial com Keras
Por que precisamos de reconhecimento
Precisamos do Reconhecimento para que seja mais fácil reconhecer ou identificar o rosto de uma pessoa, o tipo de objeto, a idade estimada de uma pessoa pelo seu rosto ou até mesmo conhecer as expressões faciais dessa pessoa.
Talvez você perceba que toda vez que tenta marcar o rosto do seu amigo em uma foto, o recurso do Facebook fez isso por você, ou seja, marcar o rosto do seu amigo sem que você precise marcá-lo primeiro. Este é o reconhecimento facial aplicado pelo Facebook para facilitar a marcação de amigos.
Então, como isso funciona? Cada vez que marcamos o rosto do nosso amigo, a IA do Facebook aprenderá e tentará prevê-lo até obter o resultado certo. O mesmo sistema que usaremos para fazer nosso próprio reconhecimento facial. Vamos começar a fazer nosso próprio reconhecimento facial usando Deep Learning
Modelo de rede
Usaremos um modelo de rede VGG16, mas com peso VGGFace.
Arquitetura do modelo VGG16
O que é VGGFace? é a implementação Keras do Deep Face Recognition introduzida por Parkhi, Omkar M. et al. “Reconhecimento facial profundo.” BMVC (2015). A estrutura usa VGG16 como arquitetura de rede.
Você pode baixar o VGGFace em github
from keras.applications.vgg16 import VGG16
from keras_vggface.vggface import VGGFace
face_model = VGGFace(model='vgg16',
weights='vggface',
input_shape=(224,224,3))
face_model.summary()
Como você pode ver o resumo da rede
_________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) (None, 224, 224, 3) 0 _________________________________________________________________ conv1_1 (Conv2D) (None, 224, 224, 64) 1792 _________________________________________________________________ conv1_2 (Conv2D) (None, 224, 224, 64) 36928 _________________________________________________________________ pool1 (MaxPooling2D) (None, 112, 112, 64) 0 _________________________________________________________________ conv2_1 (Conv2D) (None, 112, 112, 128) 73856 _________________________________________________________________ conv2_2 (Conv2D) (None, 112, 112, 128) 147584 _________________________________________________________________ pool2 (MaxPooling2D) (None, 56, 56, 128) 0 _________________________________________________________________ conv3_1 (Conv2D) (None, 56, 56, 256) 295168 _________________________________________________________________ conv3_2 (Conv2D) (None, 56, 56, 256) 590080 _________________________________________________________________ conv3_3 (Conv2D) (None, 56, 56, 256) 590080 _________________________________________________________________ pool3 (MaxPooling2D) (None, 28, 28, 256) 0 _________________________________________________________________ conv4_1 (Conv2D) (None, 28, 28, 512) 1180160 _________________________________________________________________ conv4_2 (Conv2D) (None, 28, 28, 512) 2359808 _________________________________________________________________ conv4_3 (Conv2D) (None, 28, 28, 512) 2359808 _________________________________________________________________ pool4 (MaxPooling2D) (None, 14, 14, 512) 0 _________________________________________________________________ conv5_1 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ conv5_2 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ conv5_3 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ pool5 (MaxPooling2D) (None, 7, 7, 512) 0 _________________________________________________________________ flatten (Flatten) (None, 25088) 0 _________________________________________________________________ fc6 (Dense) (None, 4096) 102764544 _________________________________________________________________ fc6/relu (Activation) (None, 4096) 0 _________________________________________________________________ fc7 (Dense) (None, 4096) 16781312 _________________________________________________________________ fc7/relu (Activation) (None, 4096) 0 _________________________________________________________________ fc8 (Dense) (None, 2622) 10742334 _________________________________________________________________ fc8/softmax (Activation) (None, 2622) 0 ================================================================= Total params: 145,002,878 Trainable params: 145,002,878 Non-trainable params: 0 _________________________________________________________________ Traceback (most recent call last):
faremos um Aprendizagem por transferência + Ajuste fino para tornar o treinamento mais rápido com pequenos conjuntos de dados. Primeiro, congelaremos as camadas de base para que elas não possam ser treinadas.
for layer in face_model.layers:
layer.trainable = False
então adicionamos nossa própria camada para reconhecer nossas faces de teste. Adicionaremos 2 camadas totalmente conectadas e uma camada de saída com 5 pessoas para detectar.
from keras.models import Model, Sequential
from keras.layers import Input, Convolution2D, ZeroPadding2D, MaxPooling2D, Flatten, Dense, Dropout, Activation
person_count = 5
last_layer = face_model.get_layer('pool5').output
x = Flatten(name='flatten')(last_layer)
x = Dense(1024, activation='relu', name='fc6')(x)
x = Dense(1024, activation='relu', name='fc7')(x)
out = Dense(person_count, activation='softmax', name='fc8')(x)
custom_face = Model(face_model.input, out)
Vamos ver nosso resumo da rede
Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) (None, 224, 224, 3) 0 _________________________________________________________________ conv1_1 (Conv2D) (None, 224, 224, 64) 1792 _________________________________________________________________ conv1_2 (Conv2D) (None, 224, 224, 64) 36928 _________________________________________________________________ pool1 (MaxPooling2D) (None, 112, 112, 64) 0 _________________________________________________________________ conv2_1 (Conv2D) (None, 112, 112, 128) 73856 _________________________________________________________________ conv2_2 (Conv2D) (None, 112, 112, 128) 147584 _________________________________________________________________ pool2 (MaxPooling2D) (None, 56, 56, 128) 0 _________________________________________________________________ conv3_1 (Conv2D) (None, 56, 56, 256) 295168 _________________________________________________________________ conv3_2 (Conv2D) (None, 56, 56, 256) 590080 _________________________________________________________________ conv3_3 (Conv2D) (None, 56, 56, 256) 590080 _________________________________________________________________ pool3 (MaxPooling2D) (None, 28, 28, 256) 0 _________________________________________________________________ conv4_1 (Conv2D) (None, 28, 28, 512) 1180160 _________________________________________________________________ conv4_2 (Conv2D) (None, 28, 28, 512) 2359808 _________________________________________________________________ conv4_3 (Conv2D) (None, 28, 28, 512) 2359808 _________________________________________________________________ pool4 (MaxPooling2D) (None, 14, 14, 512) 0 _________________________________________________________________ conv5_1 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ conv5_2 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ conv5_3 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ pool5 (MaxPooling2D) (None, 7, 7, 512) 0 _________________________________________________________________ flatten (Flatten) (None, 25088) 0 _________________________________________________________________ fc6 (Dense) (None, 1024) 25691136 _________________________________________________________________ fc7 (Dense) (None, 1024) 1049600 _________________________________________________________________ fc8 (Dense) (None, 5) 5125 ================================================================= Total params: 41,460,549 Trainable params: 26,745,861 Non-trainable params: 14,714,688
Como você pode ver acima, após a camada pool5, ela será achatada em um único vetor de recursos que será usado pela camada densa para o reconhecimento final.
Preparando nossos rostos
Agora vamos preparar nossos rostos. Eu fiz um diretório composto por 5 pessoas famosas
- Jack Ma
- Jason Statham
- Johnny Depp
- Robert Downey Jr
- Rowan Atkinson
Cada pasta contém 10 fotos, para cada processo de treinamento e avaliação. É uma quantidade muito pequena de dados, mas esse é o desafio, certo?
Usaremos a ajuda da ferramenta Keras para nos ajudar a preparar os dados. Esta função irá iterar na pasta do conjunto de dados e então prepará-lo para que possa ser usado no treinamento.
from keras.preprocessing.image import ImageDataGenerator
batch_size = 5
train_path = 'data/'
eval_path = 'eval/'
train_datagen = ImageDataGenerator(rescale=1./255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
valid_datagen = ImageDataGenerator(rescale=1./255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
train_generator = train_datagen.flow_from_directory(
train_path,
target_size=(image_size,image_size),
batch_size=batch_size,
class_mode='sparse',
color_mode='rgb')
valid_generator = valid_datagen.flow_from_directory(
directory=eval_path,
target_size=(224, 224),
color_mode='rgb',
batch_size=batch_size,
class_mode='sparse',
shuffle=True,
)
Treinando Nosso Modelo
Vamos começar nosso processo de treinamento compilando nossa rede com função de perda e otimizador. Aqui, usamos sparse_categorical_crossentropy como nossa função de perda, com a ajuda de SGD como nosso otimizador de aprendizado.
from keras.optimizers import SGD
custom_face.compile(loss='sparse_categorical_crossentropy',
optimizer=SGD(lr=1e-4, momentum=0.9),
metrics=['accuracy'])
history = custom_face.fit_generator(
train_generator,
validation_data=valid_generator,
steps_per_epoch=49/batch_size,
validation_steps=valid_generator.n,
epochs=50)
custom_face.evaluate_generator(generator=valid_generator)
custom_face.save('vgg_face.h5')
Epoch 25/50
10/9 [==============================] - 60s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5659 - val_acc: 0.5851
Epoch 26/50
10/9 [==============================] - 59s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5638 - val_acc: 0.5809
Epoch 27/50
10/9 [==============================] - 60s 6s/step - loss: 1.4779 - acc: 0.8597 - val_loss: 1.5613 - val_acc: 0.5477
Epoch 28/50
10/9 [==============================] - 60s 6s/step - loss: 1.4755 - acc: 0.9199 - val_loss: 1.5576 - val_acc: 0.5809
Epoch 29/50
10/9 [==============================] - 60s 6s/step - loss: 1.4794 - acc: 0.9153 - val_loss: 1.5531 - val_acc: 0.5892
Epoch 30/50
10/9 [==============================] - 60s 6s/step - loss: 1.4714 - acc: 0.8953 - val_loss: 1.5510 - val_acc: 0.6017
Epoch 31/50
10/9 [==============================] - 60s 6s/step - loss: 1.4552 - acc: 0.9199 - val_loss: 1.5509 - val_acc: 0.5809
Epoch 32/50
10/9 [==============================] - 60s 6s/step - loss: 1.4504 - acc: 0.9199 - val_loss: 1.5492 - val_acc: 0.5975
Epoch 33/50
10/9 [==============================] - 60s 6s/step - loss: 1.4497 - acc: 0.8998 - val_loss: 1.5490 - val_acc: 0.5851
Epoch 34/50
10/9 [==============================] - 60s 6s/step - loss: 1.4453 - acc: 0.9399 - val_loss: 1.5529 - val_acc: 0.5643
Epoch 35/50
10/9 [==============================] - 60s 6s/step - loss: 1.4399 - acc: 0.9599 - val_loss: 1.5451 - val_acc: 0.5768
Epoch 36/50
10/9 [==============================] - 60s 6s/step - loss: 1.4373 - acc: 0.8998 - val_loss: 1.5424 - val_acc: 0.5768
Epoch 37/50
10/9 [==============================] - 60s 6s/step - loss: 1.4231 - acc: 0.9199 - val_loss: 1.5389 - val_acc: 0.6183
Epoch 38/50
10/9 [==============================] - 59s 6s/step - loss: 1.4247 - acc: 0.9199 - val_loss: 1.5372 - val_acc: 0.5934
Epoch 39/50
10/9 [==============================] - 60s 6s/step - loss: 1.4153 - acc: 0.9399 - val_loss: 1.5406 - val_acc: 0.5560
Epoch 40/50
10/9 [==============================] - 60s 6s/step - loss: 1.4074 - acc: 0.9800 - val_loss: 1.5327 - val_acc: 0.6224
Epoch 41/50
10/9 [==============================] - 60s 6s/step - loss: 1.4023 - acc: 0.9800 - val_loss: 1.5305 - val_acc: 0.6100
Epoch 42/50
10/9 [==============================] - 59s 6s/step - loss: 1.3938 - acc: 0.9800 - val_loss: 1.5269 - val_acc: 0.5975
Epoch 43/50
10/9 [==============================] - 60s 6s/step - loss: 1.3897 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.6432
Epoch 44/50
10/9 [==============================] - 60s 6s/step - loss: 1.3828 - acc: 0.9800 - val_loss: 1.5210 - val_acc: 0.6556
Epoch 45/50
10/9 [==============================] - 59s 6s/step - loss: 1.3848 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.5975
Epoch 46/50
10/9 [==============================] - 60s 6s/step - loss: 1.3716 - acc: 0.9800 - val_loss: 1.5216 - val_acc: 0.6432
Epoch 47/50
10/9 [==============================] - 60s 6s/step - loss: 1.3721 - acc: 0.9800 - val_loss: 1.5195 - val_acc: 0.6266
Epoch 48/50
10/9 [==============================] - 60s 6s/step - loss: 1.3622 - acc: 0.9599 - val_loss: 1.5108 - val_acc: 0.6141
Epoch 49/50
10/9 [==============================] - 60s 6s/step - loss: 1.3452 - acc: 0.9399 - val_loss: 1.5140 - val_acc: 0.6432
Epoch 50/50
10/9 [==============================] - 60s 6s/step - loss: 1.3387 - acc: 0.9599 - val_loss: 1.5100 - val_acc: 0.6266
Como você pode ver, nossa precisão de validação é de até 64%, este é um bom resultado para uma pequena quantidade de dados de treinamento. Podemos melhorar isso adicionando mais camadas ou mais imagens de treinamento para que nosso modelo possa aprender mais sobre os rostos e obter mais precisão.
Vamos testar nosso modelo com uma imagem de teste
from keras.models import load_model
from keras.preprocessing.image import load_img, save_img, img_to_array
from keras_vggface.utils import preprocess_input
test_img = image.load_img('test.jpg', target_size=(224, 224))
img_test = image.img_to_array(test_img)
img_test = np.expand_dims(img_test, axis=0)
img_test = utils.preprocess_input(img_test)
predictions = model.predict(img_test)
predicted_class=np.argmax(predictions,axis=1)
labels = (train_generator.class_indices)
labels = dict((v,k) for k,v in labels.items())
predictions = [labels[k] for k in predicted_class]
print(predictions)
['RobertDJr']
usando a imagem de Robert Downey Jr. como nossa imagem de teste, mostra que a face prevista é verdadeira!
Previsão usando Live Cam!
Que tal testarmos nossa habilidade em implementá-lo com a entrada de uma webcam? Usando OpenCV com cascata Haar Face para encontrar nosso rosto e com a ajuda de nosso modelo de rede, podemos reconhecer a pessoa.
O primeiro passo é preparar o rosto de você e do seu amigo. Quanto mais dados tivermos, melhor será o resultado!
Prepare e treine sua rede como na etapa anterior, após a conclusão do treinamento, adicione esta linha para obter a imagem de entrada do cam
#Load trained model
from keras.models import load_model
from keras_vggface import utils
import cv2
image_size = 224
device_id = 0 #camera_device id
model = load_model('my faces.h5')
#make labels according to your dataset folder
labels = dict(fisrtname=0,secondname=1) #and so on
print(labels)
cascade_classifier = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
camera = cv2.VideoCapture(device_id)
while camera.isOpened():
ok, cam_frame = camera.read()
if not ok:
break
gray_img=cv2.cvtColor(cam_frame, cv2.COLOR_BGR2GRAY)
faces= cascade_classifier.detectMultiScale(gray_img, minNeighbors=5)
for (x,y,w,h) in faces:
cv2.rectangle(cam_frame,(x,y),(x+w,y+h),(255,255,0),2)
roi_color = cam_frame [y:y+h, x:x+w]
roi color = cv2.cvtColor(roi_color, cv2.COLOR_BGR2RGB)
roi_color = cv2.resize(roi_color, (image_size, image_size))
image = roi_color.astype(np.float32, copy=False)
image = np.expand_dims(image, axis=0)
image = preprocess_input(image, version=1) # or version=2
preds = model.predict(image)
predicted_class=np.argmax(preds,axis=1)
labels = dict((v,k) for k,v in labels.items())
name = [labels[k] for k in predicted_class]
cv2.putText(cam_frame,str(name),
(x + 10, y + 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,0,255), 2)
cv2.imshow('video image', cam_frame)
key = cv2.waitKey(30)
if key == 27: # press 'ESC' to quit
break
camera.release()
cv2.destroyAllWindows()
Qual é o melhor? Keras ou Tensorflow
Keras oferece simplicidade ao escrever o script. Podemos começar a escrever e entender diretamente com Keras, pois não é muito difícil de entender. É mais amigável e fácil de implementar, não sendo necessário criar muitas variáveis para rodar o modelo. Portanto, não precisamos entender todos os detalhes do processo de back-end.
Por outro lado, Tensorflow são as operações de baixo nível que oferecem flexibilidade e operações avançadas se você deseja fazer um gráfico ou modelo computacional arbitrário. O Tensorflow também pode visualizar o processo com a ajuda de TensorBoard e uma ferramenta de depurador especializada.
Então, se você quer começar a trabalhar com deep learning sem tanta complexidade, use o Keras. Porque Keras oferece simplicidade e facilidade de uso e implementação do que o Tensorflow. Mas se você quiser escrever seu próprio algoritmo em um projeto ou pesquisa de aprendizado profundo, você deve usar o Tensorflow.
Resumo
Então, vamos resumir tudo o que discutimos e fizemos neste tutorial.
- Keras em uma API de alto nível que é usada para facilitar redes de aprendizado profundo com a ajuda do mecanismo de back-end.
- Keras é fácil de usar e entender com suporte a python, então parece mais natural do que nunca. É bom para iniciantes que desejam aprender sobre aprendizado profundo e para pesquisadores que desejam uma API fácil de usar.
- O processo de instalação é fácil e você pode utilizar um ambiente virtual ou uma plataforma externa como AWS.
- Keras também vem com vários tipos de modelos de rede, o que nos torna mais fácil usar o modelo disponível para pré-treinar e ajustar nosso próprio modelo de rede.
- Além disso, há muitos tutoriais e artigos sobre o uso de Keras em códigos de comunidades em todo o mundo para fins de aprendizado profundo.
