emo

README.md

@@ -1,13 +0,0 @@
----
-title: Entex
-emoji: 🚀
-colorFrom: blue
-colorTo: purple
-sdk: gradio
-sdk_version: 3.0.12
-app_file: app.py
-pinned: false
-license: other
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,16 +1,70 @@
 import gradio as gr
 
-api = gr.Interface.load("huggingface/EleutherAI/gpt-j-6B")
-
-def complete_with_gpt(text):
-    # Use the last 50 characters of the text as context
-    return text[:-50] + api(text[-50:])
-
-with gr.Blocks() as demo:
-    textbox = gr.Textbox(placeholder="Type here and press enter...", lines=4)
-    btn = gr.Button("Generate")
-    
-    btn.click(complete_with_gpt, textbox, textbox)
-    
-if __name__ == "__main__":
-    demo.launch()
+from tensorflow.keras.utils import img_to_array
+import imutils
+import cv2
+from keras.models import load_model
+import numpy as np
+
+# parameters for loading data and images
+detection_model_path = 'haarcascade_files/haarcascade_frontalface_default.xml'
+emotion_model_path = 'models/_mini_XCEPTION.102-0.66.hdf5'
+
+# hyper-parameters for bounding boxes shape
+# loading models
+face_detection = cv2.CascadeClassifier(detection_model_path)
+emotion_classifier = load_model(emotion_model_path, compile=False)
+EMOTIONS = ["angry", "disgusted", "scared", "happy", "sad", "surprised",
+            "neutral"]
+
+
+def predict(frame):
+
+    frame = imutils.resize(frame, width=300)
+    gray = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
+    faces = face_detection.detectMultiScale(gray, scaleFactor=1.1,
+                                            minNeighbors=5, minSize=(30, 30),
+                                            flags=cv2.CASCADE_SCALE_IMAGE)
+
+    frameClone = frame.copy()
+    if len(faces) > 0:
+        faces = sorted(faces, reverse=True,
+                       key=lambda x: (x[2] - x[0]) * (x[3] - x[1]))[0]
+        (fX, fY, fW, fH) = faces
+        # Extract the ROI of the face from the grayscale image, resize it to a fixed 28x28 pixels, and then prepare
+        # the ROI for classification via the CNN
+        roi = gray[fY:fY + fH, fX:fX + fW]
+        roi = cv2.resize(roi, (64, 64))
+        roi = roi.astype("float") / 255.0
+        roi = img_to_array(roi)
+        roi = np.expand_dims(roi, axis=0)
+
+        preds = emotion_classifier.predict(roi)[0]
+        label = EMOTIONS[preds.argmax()]
+    else:
+        return frameClone, "Can't find your face"
+
+    probs = {}
+    cv2.putText(frameClone, label, (fX, fY - 10),
+                cv2.FONT_HERSHEY_DUPLEX, 1, (238, 164, 64), 1)
+    cv2.rectangle(frameClone, (fX, fY), (fX + fW, fY + fH),
+                  (238, 164, 64), 2)
+
+    for (i, (emotion, prob)) in enumerate(zip(EMOTIONS, preds)):
+        probs[emotion] = float(prob)
+
+    return frameClone, probs
+
+
+inp = gr.inputs.Image(source="webcam", label="Your face")
+out = [
+    gr.outputs.Image(label="Predicted Emotion"),
+    gr.outputs.Label(num_top_classes=3, label="Top 3 Probabilities")
+]
+title = "Emotion Classification"
+description = "How well can this model predict your emotions? Take a picture with your webcam, and it will guess if" \
+              " you are: happy, sad, angry, disgusted, scared, surprised, or neutral."
+thumbnail = "https://raw.githubusercontent.com/gradio-app/hub-emotion-recognition/master/thumbnail.png"
+
+gr.Interface(predict, inp, out, capture_session=True, title=title, thumbnail=thumbnail,
+             description=description).launch(inbrowser=True)

app_text_gen.py

@@ -0,0 +1,16 @@
+import gradio as gr
+
+api = gr.Interface.load("huggingface/EleutherAI/gpt-j-6B")
+
+def complete_with_gpt(text):
+    # Use the last 50 characters of the text as context
+    return text[:-50] + api(text[-50:])
+
+with gr.Blocks() as demo:
+    textbox = gr.Textbox(placeholder="Type here and press enter...", lines=4)
+    btn = gr.Button("Generate")
+    
+    btn.click(complete_with_gpt, textbox, textbox)
+    
+if __name__ == "__main__":
+    demo.launch()

fer2013/fer2013/readme.txt

@@ -0,0 +1 @@
+put the csv file downloaded from the link i have provided here

load_and_process.py

@@ -0,0 +1,30 @@
+import pandas as pd
+import cv2
+import numpy as np
+
+
+dataset_path = 'fer2013/fer2013/fer2013.csv'
+image_size=(48,48)
+
+def load_fer2013():
+        data = pd.read_csv(dataset_path)
+        pixels = data['pixels'].tolist()
+        width, height = 48, 48
+        faces = []
+        for pixel_sequence in pixels:
+            face = [int(pixel) for pixel in pixel_sequence.split(' ')]
+            face = np.asarray(face).reshape(width, height)
+            face = cv2.resize(face.astype('uint8'),image_size)
+            faces.append(face.astype('float32'))
+        faces = np.asarray(faces)
+        faces = np.expand_dims(faces, -1)
+        emotions = pd.get_dummies(data['emotion']).as_matrix()
+        return faces, emotions
+
+def preprocess_input(x, v2=True):
+    x = x.astype('float32')
+    x = x / 255.0
+    if v2:
+        x = x - 0.5
+        x = x * 2.0
+    return x

models/cnn.py

@@ -0,0 +1,353 @@
+from keras.layers import Activation, Convolution2D, Dropout, Conv2D
+from keras.layers import AveragePooling2D, BatchNormalization
+from keras.layers import GlobalAveragePooling2D
+from keras.models import Sequential
+from keras.layers import Flatten
+from keras.models import Model
+from keras.layers import Input
+from keras.layers import MaxPooling2D
+from keras.layers import SeparableConv2D
+from keras import layers
+from keras.regularizers import l2
+
+def simple_CNN(input_shape, num_classes):
+
+    model = Sequential()
+    model.add(Convolution2D(filters=16, kernel_size=(7, 7), padding='same',
+                            name='image_array', input_shape=input_shape))
+    model.add(BatchNormalization())
+    model.add(Convolution2D(filters=16, kernel_size=(7, 7), padding='same'))
+    model.add(BatchNormalization())
+    model.add(Activation('relu'))
+    model.add(AveragePooling2D(pool_size=(2, 2), padding='same'))
+    model.add(Dropout(.5))
+
+    model.add(Convolution2D(filters=32, kernel_size=(5, 5), padding='same'))
+    model.add(BatchNormalization())
+    model.add(Convolution2D(filters=32, kernel_size=(5, 5), padding='same'))
+    model.add(BatchNormalization())
+    model.add(Activation('relu'))
+    model.add(AveragePooling2D(pool_size=(2, 2), padding='same'))
+    model.add(Dropout(.5))
+
+    model.add(Convolution2D(filters=64, kernel_size=(3, 3), padding='same'))
+    model.add(BatchNormalization())
+    model.add(Convolution2D(filters=64, kernel_size=(3, 3), padding='same'))
+    model.add(BatchNormalization())
+    model.add(Activation('relu'))
+    model.add(AveragePooling2D(pool_size=(2, 2), padding='same'))
+    model.add(Dropout(.5))
+
+    model.add(Convolution2D(filters=128, kernel_size=(3, 3), padding='same'))
+    model.add(BatchNormalization())
+    model.add(Convolution2D(filters=128, kernel_size=(3, 3), padding='same'))
+    model.add(BatchNormalization())
+    model.add(Activation('relu'))
+    model.add(AveragePooling2D(pool_size=(2, 2), padding='same'))
+    model.add(Dropout(.5))
+
+    model.add(Convolution2D(filters=256, kernel_size=(3, 3), padding='same'))
+    model.add(BatchNormalization())
+    model.add(Convolution2D(filters=num_classes, kernel_size=(3, 3), padding='same'))
+    model.add(GlobalAveragePooling2D())
+    model.add(Activation('softmax',name='predictions'))
+    return model
+
+def simpler_CNN(input_shape, num_classes):
+
+    model = Sequential()
+    model.add(Convolution2D(filters=16, kernel_size=(5, 5), padding='same',
+                            name='image_array', input_shape=input_shape))
+    model.add(BatchNormalization())
+    model.add(Convolution2D(filters=16, kernel_size=(5, 5),
+                            strides=(2, 2), padding='same'))
+    model.add(BatchNormalization())
+    model.add(Activation('relu'))
+    model.add(Dropout(.25))
+
+    model.add(Convolution2D(filters=32, kernel_size=(5, 5), padding='same'))
+    model.add(BatchNormalization())
+    model.add(Convolution2D(filters=32, kernel_size=(5, 5),
+                            strides=(2, 2), padding='same'))
+    model.add(BatchNormalization())
+    model.add(Activation('relu'))
+    model.add(Dropout(.25))
+
+    model.add(Convolution2D(filters=64, kernel_size=(3, 3), padding='same'))
+    model.add(BatchNormalization())
+    model.add(Convolution2D(filters=64, kernel_size=(3, 3),
+                            strides=(2, 2), padding='same'))
+    model.add(BatchNormalization())
+    model.add(Activation('relu'))
+    model.add(Dropout(.25))
+
+    model.add(Convolution2D(filters=64, kernel_size=(1, 1), padding='same'))
+    model.add(BatchNormalization())
+    model.add(Convolution2D(filters=128, kernel_size=(3, 3),
+                            strides=(2, 2), padding='same'))
+    model.add(BatchNormalization())
+    model.add(Activation('relu'))
+    model.add(Dropout(.25))
+
+    model.add(Convolution2D(filters=256, kernel_size=(1, 1), padding='same'))
+    model.add(BatchNormalization())
+    model.add(Convolution2D(filters=128, kernel_size=(3, 3),
+                            strides=(2, 2), padding='same'))
+
+    model.add(Convolution2D(filters=256, kernel_size=(1, 1), padding='same'))
+    model.add(BatchNormalization())
+    model.add(Convolution2D(filters=num_classes, kernel_size=(3, 3),
+                            strides=(2, 2), padding='same'))
+
+    model.add(Flatten())
+    #model.add(GlobalAveragePooling2D())
+    model.add(Activation('softmax',name='predictions'))
+    return model
+
+def tiny_XCEPTION(input_shape, num_classes, l2_regularization=0.01):
+    regularization = l2(l2_regularization)
+
+    # base
+    img_input = Input(input_shape)
+    x = Conv2D(5, (3, 3), strides=(1, 1), kernel_regularizer=regularization,
+                                            use_bias=False)(img_input)
+    x = BatchNormalization()(x)
+    x = Activation('relu')(x)
+    x = Conv2D(5, (3, 3), strides=(1, 1), kernel_regularizer=regularization,
+                                            use_bias=False)(x)
+    x = BatchNormalization()(x)
+    x = Activation('relu')(x)
+
+    # module 1
+    residual = Conv2D(8, (1, 1), strides=(2, 2),
+                      padding='same', use_bias=False)(x)
+    residual = BatchNormalization()(residual)
+
+    x = SeparableConv2D(8, (3, 3), padding='same',
+                        kernel_regularizer=regularization,
+                        use_bias=False)(x)
+    x = BatchNormalization()(x)
+    x = Activation('relu')(x)
+    x = SeparableConv2D(8, (3, 3), padding='same',
+                        kernel_regularizer=regularization,
+                        use_bias=False)(x)
+    x = BatchNormalization()(x)
+
+    x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
+    x = layers.add([x, residual])
+
+    # module 2
+    residual = Conv2D(16, (1, 1), strides=(2, 2),
+                      padding='same', use_bias=False)(x)
+    residual = BatchNormalization()(residual)
+
+    x = SeparableConv2D(16, (3, 3), padding='same',
+                        kernel_regularizer=regularization,
+                        use_bias=False)(x)
+    x = BatchNormalization()(x)
+    x = Activation('relu')(x)
+    x = SeparableConv2D(16, (3, 3), padding='same',
+                        kernel_regularizer=regularization,
+                        use_bias=False)(x)
+    x = BatchNormalization()(x)
+
+    x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
+    x = layers.add([x, residual])
+
+    # module 3
+    residual = Conv2D(32, (1, 1), strides=(2, 2),
+                      padding='same', use_bias=False)(x)
+    residual = BatchNormalization()(residual)
+
+    x = SeparableConv2D(32, (3, 3), padding='same',
+                        kernel_regularizer=regularization,
+                        use_bias=False)(x)
+    x = BatchNormalization()(x)
+    x = Activation('relu')(x)
+    x = SeparableConv2D(32, (3, 3), padding='same',
+                        kernel_regularizer=regularization,
+                        use_bias=False)(x)
+    x = BatchNormalization()(x)
+
+    x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
+    x = layers.add([x, residual])
+
+    # module 4
+    residual = Conv2D(64, (1, 1), strides=(2, 2),
+                      padding='same', use_bias=False)(x)
+    residual = BatchNormalization()(residual)
+
+    x = SeparableConv2D(64, (3, 3), padding='same',
+                        kernel_regularizer=regularization,
+                        use_bias=False)(x)
+    x = BatchNormalization()(x)
+    x = Activation('relu')(x)
+    x = SeparableConv2D(64, (3, 3), padding='same',
+                        kernel_regularizer=regularization,
+                        use_bias=False)(x)
+    x = BatchNormalization()(x)
+
+    x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
+    x = layers.add([x, residual])
+
+    x = Conv2D(num_classes, (3, 3),
+            #kernel_regularizer=regularization,
+            padding='same')(x)
+    x = GlobalAveragePooling2D()(x)
+    output = Activation('softmax',name='predictions')(x)
+
+    model = Model(img_input, output)
+    return model
+
+
+def mini_XCEPTION(input_shape, num_classes, l2_regularization=0.01):
+    regularization = l2(l2_regularization)
+
+    # base
+    img_input = Input(input_shape)
+    x = Conv2D(8, (3, 3), strides=(1, 1), kernel_regularizer=regularization,
+                                            use_bias=False)(img_input)
+    x = BatchNormalization()(x)
+    x = Activation('relu')(x)
+    x = Conv2D(8, (3, 3), strides=(1, 1), kernel_regularizer=regularization,
+                                            use_bias=False)(x)
+    x = BatchNormalization()(x)
+    x = Activation('relu')(x)
+
+    # module 1
+    residual = Conv2D(16, (1, 1), strides=(2, 2),
+                      padding='same', use_bias=False)(x)
+    residual = BatchNormalization()(residual)
+
+    x = SeparableConv2D(16, (3, 3), padding='same',
+                        kernel_regularizer=regularization,
+                        use_bias=False)(x)
+    x = BatchNormalization()(x)
+    x = Activation('relu')(x)
+    x = SeparableConv2D(16, (3, 3), padding='same',
+                        kernel_regularizer=regularization,
+                        use_bias=False)(x)
+    x = BatchNormalization()(x)
+
+    x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
+    x = layers.add([x, residual])
+
+    # module 2
+    residual = Conv2D(32, (1, 1), strides=(2, 2),
+                      padding='same', use_bias=False)(x)
+    residual = BatchNormalization()(residual)
+
+    x = SeparableConv2D(32, (3, 3), padding='same',
+                        kernel_regularizer=regularization,
+                        use_bias=False)(x)
+    x = BatchNormalization()(x)
+    x = Activation('relu')(x)
+    x = SeparableConv2D(32, (3, 3), padding='same',
+                        kernel_regularizer=regularization,
+                        use_bias=False)(x)
+    x = BatchNormalization()(x)
+
+    x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
+    x = layers.add([x, residual])
+
+    # module 3
+    residual = Conv2D(64, (1, 1), strides=(2, 2),
+                      padding='same', use_bias=False)(x)
+    residual = BatchNormalization()(residual)
+
+    x = SeparableConv2D(64, (3, 3), padding='same',
+                        kernel_regularizer=regularization,
+                        use_bias=False)(x)
+    x = BatchNormalization()(x)
+    x = Activation('relu')(x)
+    x = SeparableConv2D(64, (3, 3), padding='same',
+                        kernel_regularizer=regularization,
+                        use_bias=False)(x)
+    x = BatchNormalization()(x)
+
+    x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
+    x = layers.add([x, residual])
+
+    # module 4
+    residual = Conv2D(128, (1, 1), strides=(2, 2),
+                      padding='same', use_bias=False)(x)
+    residual = BatchNormalization()(residual)
+
+    x = SeparableConv2D(128, (3, 3), padding='same',
+                        kernel_regularizer=regularization,
+                        use_bias=False)(x)
+    x = BatchNormalization()(x)
+    x = Activation('relu')(x)
+    x = SeparableConv2D(128, (3, 3), padding='same',
+                        kernel_regularizer=regularization,
+                        use_bias=False)(x)
+    x = BatchNormalization()(x)
+
+    x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
+    x = layers.add([x, residual])
+
+    x = Conv2D(num_classes, (3, 3),
+            #kernel_regularizer=regularization,
+            padding='same')(x)
+    x = GlobalAveragePooling2D()(x)
+    output = Activation('softmax',name='predictions')(x)
+
+    model = Model(img_input, output)
+    return model
+
+def big_XCEPTION(input_shape, num_classes):
+    img_input = Input(input_shape)
+    x = Conv2D(32, (3, 3), strides=(2, 2), use_bias=False)(img_input)
+    x = BatchNormalization(name='block1_conv1_bn')(x)
+    x = Activation('relu', name='block1_conv1_act')(x)
+    x = Conv2D(64, (3, 3), use_bias=False)(x)
+    x = BatchNormalization(name='block1_conv2_bn')(x)
+    x = Activation('relu', name='block1_conv2_act')(x)
+
+    residual = Conv2D(128, (1, 1), strides=(2, 2),
+                      padding='same', use_bias=False)(x)
+    residual = BatchNormalization()(residual)
+
+    x = SeparableConv2D(128, (3, 3), padding='same', use_bias=False)(x)
+    x = BatchNormalization(name='block2_sepconv1_bn')(x)
+    x = Activation('relu', name='block2_sepconv2_act')(x)
+    x = SeparableConv2D(128, (3, 3), padding='same', use_bias=False)(x)
+    x = BatchNormalization(name='block2_sepconv2_bn')(x)
+
+    x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
+    x = layers.add([x, residual])
+
+    residual = Conv2D(256, (1, 1), strides=(2, 2),
+                      padding='same', use_bias=False)(x)
+    residual = BatchNormalization()(residual)
+
+    x = Activation('relu', name='block3_sepconv1_act')(x)
+    x = SeparableConv2D(256, (3, 3), padding='same', use_bias=False)(x)
+    x = BatchNormalization(name='block3_sepconv1_bn')(x)
+    x = Activation('relu', name='block3_sepconv2_act')(x)
+    x = SeparableConv2D(256, (3, 3), padding='same', use_bias=False)(x)
+    x = BatchNormalization(name='block3_sepconv2_bn')(x)
+
+    x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
+    x = layers.add([x, residual])
+    x = Conv2D(num_classes, (3, 3),
+            #kernel_regularizer=regularization,
+            padding='same')(x)
+    x = GlobalAveragePooling2D()(x)
+    output = Activation('softmax',name='predictions')(x)
+
+    model = Model(img_input, output)
+    return model
+
+
+if __name__ == "__main__":
+    input_shape = (64, 64, 1)
+    num_classes = 7
+    #model = tiny_XCEPTION(input_shape, num_classes)
+    #model.summary()
+    #model = mini_XCEPTION(input_shape, num_classes)
+    #model.summary()
+    #model = big_XCEPTION(input_shape, num_classes)
+    #model.summary()
+    model = simple_CNN((48, 48, 1), num_classes)
+    model.summary()

real_time_video.py

@@ -0,0 +1,84 @@
+from keras.preprocessing.image import img_to_array
+import imutils
+import cv2
+from keras.models import load_model
+import numpy as np
+
+# parameters for loading data and images
+detection_model_path = 'haarcascade_files/haarcascade_frontalface_default.xml'
+emotion_model_path = 'models/_mini_XCEPTION.102-0.66.hdf5'
+
+# hyper-parameters for bounding boxes shape
+# loading models
+face_detection = cv2.CascadeClassifier(detection_model_path)
+emotion_classifier = load_model(emotion_model_path, compile=False)
+EMOTIONS = ["angry" ,"disgust","scared", "happy", "sad", "surprised",
+ "neutral"]
+
+
+#feelings_faces = []
+#for index, emotion in enumerate(EMOTIONS):
+   # feelings_faces.append(cv2.imread('emojis/' + emotion + '.png', -1))
+
+# starting video streaming
+cv2.namedWindow('your_face')
+camera = cv2.VideoCapture(0)
+while True:
+    frame = camera.read()[1]
+    #reading the frame
+    frame = imutils.resize(frame,width=300)
+    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    faces = face_detection.detectMultiScale(gray,scaleFactor=1.1,minNeighbors=5,minSize=(30,30),flags=cv2.CASCADE_SCALE_IMAGE)
+    
+    canvas = np.zeros((250, 300, 3), dtype="uint8")
+    frameClone = frame.copy()
+    if len(faces) > 0:
+        faces = sorted(faces, reverse=True,
+        key=lambda x: (x[2] - x[0]) * (x[3] - x[1]))[0]
+        (fX, fY, fW, fH) = faces
+                    # Extract the ROI of the face from the grayscale image, resize it to a fixed 28x28 pixels, and then prepare
+            # the ROI for classification via the CNN
+        roi = gray[fY:fY + fH, fX:fX + fW]
+        roi = cv2.resize(roi, (64, 64))
+        roi = roi.astype("float") / 255.0
+        roi = img_to_array(roi)
+        roi = np.expand_dims(roi, axis=0)
+        
+        
+        preds = emotion_classifier.predict(roi)[0]
+        emotion_probability = np.max(preds)
+        label = EMOTIONS[preds.argmax()]
+    else: continue
+
+ 
+    for (i, (emotion, prob)) in enumerate(zip(EMOTIONS, preds)):
+                # construct the label text
+                text = "{}: {:.2f}%".format(emotion, prob * 100)
+
+                # draw the label + probability bar on the canvas
+               # emoji_face = feelings_faces[np.argmax(preds)]
+
+                
+                w = int(prob * 300)
+                cv2.rectangle(canvas, (7, (i * 35) + 5),
+                (w, (i * 35) + 35), (0, 0, 255), -1)
+                cv2.putText(canvas, text, (10, (i * 35) + 23),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.45,
+                (255, 255, 255), 2)
+                cv2.putText(frameClone, label, (fX, fY - 10),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.45, (0, 0, 255), 2)
+                cv2.rectangle(frameClone, (fX, fY), (fX + fW, fY + fH),
+                              (0, 0, 255), 2)
+#    for c in range(0, 3):
+#        frame[200:320, 10:130, c] = emoji_face[:, :, c] * \
+#        (emoji_face[:, :, 3] / 255.0) + frame[200:320,
+#        10:130, c] * (1.0 - emoji_face[:, :, 3] / 255.0)
+
+
+    cv2.imshow('your_face', frameClone)
+    cv2.imshow("Probabilities", canvas)
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+
+camera.release()
+cv2.destroyAllWindows()

requirements.txt

@@ -1 +1,7 @@
-nltk==3.5
+opencv_python==4.1.1.26
+tensorflow==1.14
+Keras==2.3.1
+pandas==0.25.3
+numpy==1.17.4
+imutils==0.5.3
+scikit_learn==0.22.1

train_emotion_classifier.py

@@ -0,0 +1,64 @@
+"""
+Description: Train emotion classification model
+"""
+
+from keras.callbacks import CSVLogger, ModelCheckpoint, EarlyStopping
+from keras.callbacks import ReduceLROnPlateau
+from keras.preprocessing.image import ImageDataGenerator
+from load_and_process import load_fer2013
+from load_and_process import preprocess_input
+from models.cnn import mini_XCEPTION
+from sklearn.model_selection import train_test_split
+
+# parameters
+batch_size = 32
+num_epochs = 10000
+input_shape = (48, 48, 1)
+validation_split = .2
+verbose = 1
+num_classes = 7
+patience = 50
+base_path = 'models/'
+
+# data generator
+data_generator = ImageDataGenerator(
+                        featurewise_center=False,
+                        featurewise_std_normalization=False,
+                        rotation_range=10,
+                        width_shift_range=0.1,
+                        height_shift_range=0.1,
+                        zoom_range=.1,
+                        horizontal_flip=True)
+
+# model parameters/compilation
+model = mini_XCEPTION(input_shape, num_classes)
+model.compile(optimizer='adam', loss='categorical_crossentropy',
+              metrics=['accuracy'])
+model.summary()
+
+
+
+
+
+    # callbacks
+log_file_path = base_path + '_emotion_training.log'
+csv_logger = CSVLogger(log_file_path, append=False)
+early_stop = EarlyStopping('val_loss', patience=patience)
+reduce_lr = ReduceLROnPlateau('val_loss', factor=0.1,
+                                  patience=int(patience/4), verbose=1)
+trained_models_path = base_path + '_mini_XCEPTION'
+model_names = trained_models_path + '.{epoch:02d}-{val_acc:.2f}.hdf5'
+model_checkpoint = ModelCheckpoint(model_names, 'val_loss', verbose=1,
+                                                    save_best_only=True)
+callbacks = [model_checkpoint, csv_logger, early_stop, reduce_lr]
+
+# loading dataset
+faces, emotions = load_fer2013()
+faces = preprocess_input(faces)
+num_samples, num_classes = emotions.shape
+xtrain, xtest,ytrain,ytest = train_test_split(faces, emotions,test_size=0.2,shuffle=True)
+model.fit_generator(data_generator.flow(xtrain, ytrain,
+                                            batch_size),
+                        steps_per_epoch=len(xtrain) / batch_size,
+                        epochs=num_epochs, verbose=1, callbacks=callbacks,
+                        validation_data=(xtest,ytest))