Tensorflow. Reconocimiento facial con inteligencia artificial (2/3)

22. Reconocimiento facial con inteligencia artificial (2)

• Hola a todos.Una vez finalizado el curso de google, vamos a entrenar un modelo para hacer un ejemplo de reconocimiento facial.Este ejemplo lo dividiremos en tres vídeos, que estructuraremos de la siguiente manera.

• En el segundo vídeo que podéis ver a continuación nos centramos en definir y entrenar una red convolucional con Keras. También veremos el código necesario para este propósito.

• A continuación os dejo el código visto en el vídeo.

#Imporatamos el fichero utils que tiene la lógica necesaria para obtener 15 puntos 

#representativos de las caras.

from utils import *

# load_data es un método definido en el fichero utils para cargar los csv que 

#tenemos en la carpeta data:training.csv y

# test.csv'

X_train, y_train = load_data()

print("X_train.shape == {}".format(X_train.shape))

print("y_train.shape == {}; y_train.min == {:.3f}; y_train.max == {:.3f}".format(

    y_train.shape, y_train.min(), y_train.max()))

# cargamos datos entrenamiento que son los dos csv que tene

X_test, _ = load_data(test=True)

print("X_test.shape == {}".format(X_test.shape))

#muestro los puntos 15 puntos representativos de las caras de del conjunto de entrenamiento 

import matplotlib.pyplot as plt

%matplotlib inline

fig = plt.figure(figsize=(20,20))

fig.subplots_adjust(left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05)

for i in range(9):

    ax = fig.add_subplot(3, 3, i + 1, xticks=[], yticks=[])

    plot_data(X_train[i], y_train[i], ax)

# Importamos librerias necesarias 

from keras.models import Sequential

from keras.layers import Convolution2D, MaxPooling2D, Dropout

from keras.layers import Flatten, Dense

# El modelo debe aceptar imágenes en escala de 96x96 píxeles.

# Debe tener una capa de salida totalmente conectada con 30 valores 

#(2 para cada punto clave facial)

# Como funcion de activacion utilizamos relu que activa una neoruna solo si es mayor que cero.

shape = (96,96)

modelo = Sequential()

modelo.add(Convolution2D(16,(2,2),padding='same',input_shape=(96,96, 1), activation='relu'))

modelo.add(MaxPooling2D(pool_size=3, data_format="channels_first"))

modelo.add(Convolution2D(32,(3,3),padding='same', activation='relu'))

modelo.add(MaxPooling2D(pool_size=3))

modelo.add(Dropout(0.2))

modelo.add(Convolution2D(64,(3,3),padding='same',activation='relu'))

modelo.add(MaxPooling2D(pool_size=3))

modelo.add(Dropout(0.2))

modelo.add(Convolution2D(128,(3,3),padding='same', activation='relu'))

modelo.add(MaxPooling2D(pool_size=3))

modelo.add(Dropout(0.2))

modelo.add(Flatten())

modelo.add(Dense(256,activation='relu'))

modelo.add(Dropout(0.2))

modelo.add(Dense(30))

modelo.summary()

from keras.optimizers import SGD, RMSprop, Adagrad, Adadelta, Adam, Adamax, Nadam

from keras.callbacks import ModelCheckpoint, History  

iteraciones = 50

histo = History()

## Compilamo el modelo

def compilarModelo(modelo, iteraciones):

    

    ruta = 'model.hdf5'

    modelo.compile(optimizer='adam', loss='mse', metrics=['accuracy'])

    checkpointer = ModelCheckpoint(filepath=ruta, 

                                   verbose=1, save_best_only=True)

    ## Entrenamos el modelo

    hist = modelo.fit(X_train, y_train, validation_split=0.2,

              epochs=iteraciones, batch_size=20, callbacks=[checkpointer, histo], verbose=1)

    

    modelo.save(ruta)

    

    return hist

# Booleano con el controlamos si entrenar el modelo o no

entrenarModelo = False

if entrenarModelo is True:

    hist = compilarModelo(modelo, iteraciones) 

else:

    modelo.load_weights('model.hdf5')

def obtenerPuntosClave(imagen, caras=None):

    

  

    #lista parea (cara, puntosClave)

    resultado = []

    

    if caras is None:

        caras = get_faces(imagen)

    

    # mismo tamaño que los conjuntos de entrenamiento y validacion

    carasForma = (96, 96)

    

    copiaImagen = np.copy(imagen)

    #Por cada cara detectamos puntos clave y características

    for (x,y,w,h) in caras:

        #Recortamos la región de la imagen donde esta la cara

        cara = copiaImagen[y:y+h,x:x+w]

        # Cara convertida a escala de grises y tamaño 96x96x1

        caraGris = cv2.cvtColor(cara, cv2.COLOR_BGR2GRAY)

        caraGrisRedimensionar = cv2.resize(caraGris, carasForma) / 255

        # Adaptando entrada a (1, 96, 96, 1)

        inputs = np.expand_dims(np.expand_dims(caraGrisRedimensionar, axis=-1), axis=0)

                                

        # obtener puntos clave                        

        puntosClavePrediccion = modelo.predict(inputs)

        # Todos los puntos clave en una sola matriz plana. 

        # Recuperaremos puntos clave como (x, y) con (idx, idx + 1) valores.

        puntosClavePrediccion = np.squeeze(puntosClavePrediccion)

        

        puntosClave = []        

        for idx in range(0, len(puntosClavePrediccion), 2):

            #Factor de escala (revertir escala)

            x_scale_factor = cara.shape[0]/carasForma[0] 

            y_scale_factor = cara.shape[1]/carasForma[1] 

            x_center_left_offset = puntosClavePrediccion[idx] * carasForma[0]/2 + carasForma[0]/2 

            y_center_left_offset = puntosClavePrediccion[idx + 1] * carasForma[1]/2 + carasForma[1]/2

            

            x_center = int(x + (x_scale_factor * x_center_left_offset))

            y_center = int(y + (y_scale_factor * y_center_left_offset))

            puntosClave.append([x_center, y_center])

        

        resultado.append([(x,y,w,h), puntosClave])

    

    return resultado

def mostrarImagenCaracteristicas(image_path):

    imagen = cargaImagen(image_path)

    caras = dameCaras(imagen)

    puntosClave = obtenerPuntosClave(imagen, caras)

    imagenConCaras = pintarCaras(imagen, caras ,plot=False)

    pintarPuntosClave(imagenConCaras, puntosClave)

mostrarImagenCaracteristicas('imagenes/clubdelalucha.jpg')