process_model.py

"""
Diese Klasse macht das Training des Models möglich
"""
import argparse

import cv2
import glob
import random
import numpy as np
import sys
import logging

from email_service import sendMail

logfile = 'logs/process_model.log'

"""
Erstellt und gibt das Log-File aus 
"""
logging.basicConfig(level=logging.NOTSET, format='%(asctime)s %(levelname)-8s %(message)s',
                    datefmt='%m-%d %H:%M',
                    filename=logfile)

"""
Argument Parser erlaubt Parameter für die Verarbeitung anzugeben.
"""

parser = argparse.ArgumentParser(description='Process Model Application')
parser.add_argument('--dataset', action='store', dest='dataset', default='resources/img_data/dataset/', help='path to dataset')
parser.add_argument('-i', action='store', dest='iterations', type=int, default=30, help='declare processing iterations')
parser.add_argument('-e', action='append', dest='emotions', default=['happy', 'neutral', 'surprise'], help='declare emotions that should be processed')
parser.add_argument('-p', action='append', dest='properties', help='pre-processing steps')
parser.add_argument('--test', action='store_true', help='prevent writing new model to file system')
parser.add_argument('--csv', action='store_true', help='activate csv processing')
parser.add_argument('--email', action='store_true', help='activate email notifications')
arguments = parser.parse_args()
logging.debug(arguments)

dataset_path = arguments.dataset
iterations = arguments.iterations
emotions = arguments.emotions
properties = arguments.properties
csv = arguments.csv
email = arguments.email
test = arguments.test

"""
Liest Input Parameter 
"""
logging.info('Fisherface training started')

if email:
    sendMail('Fisherface training started')

def _get_faces_from_emotion(emotion):
    """
    Holt alle Dateien zu einer Emotion aus dem Dataset, mischt sie und teilt sie in ein Trainings- und Prognoseset.
    :param emotion: Die Emotion
    :return: training, prediction
    """
    files = glob.glob(dataset_path + '{}/*'.format(emotion))
    random.shuffle(files)

    """
    Mischt das Dataset in Trainings- und Vergleichsbilder im Verhältnis 80 zu 20 
    """
    training = files[:int(len(files) * 0.8)]
    prediction = files[-int(len(files) * 0.2):]

    return training, prediction


def image_preprocessing(image):
    """
    Preprocessing der Dateien
    :param item: Bild
    :return:
    """
    img = cv2.imread(image)  # open image
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)  # convert to grayscale
    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
    face = clahe.apply(gray)
    return face


def make_sets():
    training_data = []
    training_labels = []
    prediction_data = []
    prediction_labels = []
    for emotion in emotions:
        training, prediction = _get_faces_from_emotion(emotion)
        # Append data to training and prediction list, and generate labels 0-7
        for item in training:
            img = image_preprocessing(item)
            training_data.append(img)  # append image array to training data list
            training_labels.append(emotions.index(emotion))

        for item in prediction:  # repeat above process for prediction set
            img = image_preprocessing(item)
            prediction_data.append(img)
            prediction_labels.append(emotions.index(emotion))

    return training_data, training_labels, prediction_data, prediction_labels


def run_recognizer():
    training_data, training_labels, prediction_data, prediction_labels = make_sets()

    fishface.train(training_data, np.asarray(training_labels))

    cnt = 0
    correct = 0
    incorrect = 0
    for image in prediction_data:
        pred, conf = fishface.predict(image)
        if pred == prediction_labels[cnt]:
            correct += 1
            cnt += 1
        else:
            incorrect += 1
            cnt += 1
    return ((100 * correct) / (correct + incorrect))

"""
Emotions Liste 
"""
fishface = cv2.face.FisherFaceRecognizer_create()
metascore = []

for i in range(1, iterations+1):
    correct = run_recognizer()
    logging.info("{} : {}%".format(i, int(correct)))
    metascore.append(correct)

    if i % (int(iterations/4)) == 0 and email:
        sendMail(str(i) + ' iterations done', body='up-to-date average: {}%'.format(np.mean(metascore)))

if csv:
    file = open("resources/csv/{}.csv".format('_'.join(properties).lower()), "w")
    for entry in metascore:
        file.write("{}\n".format(int(entry)))

    file.close()

logging.info("Fisherface training finished - {}% average\n".format(np.mean(metascore)))

if not test:
    fishface.write('img_data/models/detection_model.xml')

if email:
    sendMail('Fisherface training finished')