adding changes

.gitignore

@@ -0,0 +1,174 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+train/
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc

README.md

@@ -0,0 +1 @@
+# face-emotion-detection

app.py

@@ -0,0 +1,286 @@
+from flask import Flask, request, jsonify , render_template , Response
+from flask_cors import CORS
+from models.clip_emotion import detect_emotion , detect_age
+import cv2
+from camera import VideoCamera
+import os
+from cnn_emotion import detect_emotion as detect_emotion_cnn
+# from cnn_lstm import detect_cnn_lstm_emotion
+from cnn_resnet import detect_cnn_resnetemotion
+
+from cnn import detect_cnn
+from knn import detect_knn
+from svm import detect_svm
+from randomforest import detect_rf
+from logisticregression import detect_lr
+
+import logging
+
+# Configure logging
+logging.basicConfig(
+    level=logging.DEBUG,  # Change to INFO in production
+    format='[%(asctime)s] %(levelname)s in %(module)s: %(message)s'
+)
+
+
+app = Flask(__name__)
+CORS(app)
+
+UPLOAD_FOLDER = "temp_frames"
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+@app.route('/')
+def home():
+    return render_template('index.html')
+
+@app.route('/knn')
+def index_knn():
+    return render_template('knn.html')
+
+@app.route('/svm')
+def index_svm():
+    return render_template('svm.html')
+
+@app.route('/logistic_regression')
+def index_lr():
+    return render_template('lr.html')
+
+@app.route('/randomforest')
+def index_rf():
+    return render_template('rf.html')
+
+@app.route('/vit')
+def index_vit():
+    return render_template('vit.html')
+
+@app.route('/cnn')
+def index_cnnonly():
+    return render_template('cnn.html')
+
+@app.route('/cnnkeras')
+def index_cnn():
+    return render_template('cnnkeras.html')
+
+@app.route('/cnnlstm')
+def index_cnnlstm():
+    return render_template('cnn_lstm.html')
+
+@app.route('/cnn_resnet')
+def index_cnn_resnet():
+    return render_template('cnn_resnet.html')
+
+def gen(camera):
+    while True:
+        frame = camera.get_frame()
+        yield (b'--frame\r\n'
+               b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n\r\n')
+
+@app.route('/video_feed', methods=["POST"])
+def video_feed():
+    # return Response(gen(VideoCamera()),
+    #                 mimetype='multipart/x-mixed-replace; boundary=frame')
+    
+    if "frame" not in request.files:
+        return jsonify({"error": "No frame received"}), 400
+
+    file = request.files["frame"]
+    filepath = os.path.join(UPLOAD_FOLDER, file.filename)
+    file.save(filepath)
+    try:
+        emotion, image_base64 = detect_emotion_cnn(filepath)
+        return jsonify({"emotion": emotion, "image": image_base64})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/analyze", methods=["POST"])
+def analyze():
+    if "frame" not in request.files:
+        return jsonify({"error": "No frame received"}), 400
+
+    file = request.files["frame"]
+    filepath = os.path.join(UPLOAD_FOLDER, file.filename)
+    file.save(filepath)
+
+    try:
+        emotion, scores = detect_emotion(filepath)
+        age, age_scores = detect_age(filepath)
+        return jsonify({"emotion": emotion, "scores": scores, "age": age})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/cnn_lstm_video_feed', methods=["POST"])
+def cnn_lstm_video_feed():
+    
+    if "frame" not in request.files:
+        return jsonify({"error": "No frame received"}), 400
+
+    file = request.files["frame"]
+    filepath = os.path.join(UPLOAD_FOLDER, file.filename)
+    file.save(filepath)
+    try:
+        emotion, image_base64 = detect_emotion_cnn(filepath)
+        return jsonify({"emotion": emotion, "image": image_base64})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/cnn_resnet', methods=['POST'])
+def cnn_resnet():
+    if "frame" not in request.files:
+        logging.warning("No frame in request")
+        return jsonify({"error": "No frame received"}), 400
+    file = request.files["frame"]
+    filepath = os.path.join(UPLOAD_FOLDER, file.filename)
+    logging.info(f"File saved to {filepath}")
+    file.save(filepath)
+    try:
+        emotion, image_base64 = detect_cnn_resnetemotion(filepath)
+        return jsonify({"emotion": emotion, "image": image_base64})
+    except Exception as e:
+        logging.error(f"Failed to save file: {e}")
+        return jsonify({"error": str(e)}), 500
+    
+@app.route('/cnn', methods=['POST'])
+def cnn():
+    if "frame" not in request.files:
+        logging.warning("No frame in request")
+        return jsonify({"error": "No frame received"}), 400
+    file = request.files["frame"]
+    filepath = os.path.join(UPLOAD_FOLDER, file.filename)
+    logging.info(f"File saved to {filepath}")
+    file.save(filepath)
+    try:
+        emotion, image_base64 = detect_cnn(filepath)
+        return jsonify({"emotion": emotion, "image": image_base64})
+    except Exception as e:
+        logging.error(f"Failed to save file: {e}")
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/knn', methods=['POST'])
+def knnn():
+    if "frame" not in request.files:
+        logging.warning("No frame in request")
+        return jsonify({"error": "No frame received"}), 400
+    file = request.files["frame"]
+    filepath = os.path.join(UPLOAD_FOLDER, file.filename)
+    logging.info(f"File saved to {filepath}")
+    file.save(filepath)
+    try:
+        emotion, image_base64 = detect_knn(filepath)
+        return jsonify({"emotion": emotion, "image": image_base64})
+    except Exception as e:
+        logging.error(f"Failed to save file: {e}")
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/svm', methods=['POST'])
+def svmm():
+    if "frame" not in request.files:
+        logging.warning("No frame in request")
+        return jsonify({"error": "No frame received"}), 400
+    file = request.files["frame"]
+    filepath = os.path.join(UPLOAD_FOLDER, file.filename)
+    logging.info(f"File saved to {filepath}")
+    file.save(filepath)
+    try:
+        emotion, image_base64 = detect_svm(filepath)
+        return jsonify({"emotion": emotion, "image": image_base64})
+    except Exception as e:
+        logging.error(f"Failed to save file: {e}")
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/randomforest', methods=['POST'])
+def rff():
+    if "frame" not in request.files:
+        logging.warning("No frame in request")
+        return jsonify({"error": "No frame received"}), 400
+    file = request.files["frame"]
+    filepath = os.path.join(UPLOAD_FOLDER, file.filename)
+    logging.info(f"File saved to {filepath}")
+    file.save(filepath)
+    try:
+        emotion, image_base64 = detect_rf(filepath)
+        return jsonify({"emotion": emotion, "image": image_base64})
+    except Exception as e:
+        logging.error(f"Failed to save file: {e}")
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/logistic_regression', methods=['POST'])
+def lr():
+    if "frame" not in request.files:
+        logging.warning("No frame in request")
+        return jsonify({"error": "No frame received"}), 400
+    file = request.files["frame"]
+    filepath = os.path.join(UPLOAD_FOLDER, file.filename)
+    logging.info(f"File saved to {filepath}")
+    file.save(filepath)
+    try:
+        emotion, image_base64 = detect_lr(filepath)
+        return jsonify({"emotion": emotion, "image": image_base64})
+    except Exception as e:
+        logging.error(f"Failed to save file: {e}")
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/reports")
+def show_reports():
+    svm_report = """[RESULTS] SVM Classification Report
+              precision    recall  f1-score   support
+       angry       0.33      0.35      0.34       779
+     disgust       0.56      0.16      0.25        92
+        fear       0.33      0.25      0.29       838
+       happy       0.59      0.68      0.63      1473
+     neutral       0.42      0.44      0.43       987
+         sad       0.35      0.33      0.34       977
+    surprise       0.57      0.54      0.55       596
+    accuracy                           0.45      5742
+   macro avg       0.45      0.39      0.40      5742
+weighted avg       0.44      0.45      0.44      5742"""
+
+    rf_report = """[RESULTS] Random Forest Classification Report
+              precision    recall  f1-score   support
+       angry       0.38      0.20      0.26       779
+     disgust       1.00      0.27      0.43        92
+        fear       0.39      0.21      0.28       838
+       happy       0.47      0.82      0.60      1473
+     neutral       0.40      0.43      0.41       987
+         sad       0.37      0.31      0.34       977
+    surprise       0.71      0.50      0.58       596
+    accuracy                           0.45      5742
+   macro avg       0.53      0.39      0.41      5742
+weighted avg       0.45      0.45      0.42      5742"""
+
+    knn_report = """[RESULTS] k-NN Classification Report
+              precision    recall  f1-score   support
+       angry       0.34      0.35      0.35       779
+     disgust       0.39      0.36      0.38        92
+        fear       0.38      0.31      0.34       838
+       happy       0.53      0.75      0.62      1473
+     neutral       0.39      0.42      0.40       987
+         sad       0.40      0.21      0.28       977
+    surprise       0.56      0.47      0.51       596
+    accuracy                           0.45      5742
+   macro avg       0.43      0.41      0.41      5742
+weighted avg       0.44      0.45      0.43      5742"""
+
+    lr_report = """[RESULTS] Logistic Regression Classification Report
+              precision    recall  f1-score   support
+       angry       0.33      0.31      0.32       779
+     disgust       0.56      0.15      0.24        92
+        fear       0.32      0.22      0.26       838
+       happy       0.57      0.70      0.63      1473
+     neutral       0.41      0.43      0.42       987
+         sad       0.34      0.31      0.32       977
+    surprise       0.51      0.55      0.53       596
+    accuracy                           0.44      5742
+   macro avg       0.43      0.38      0.39      5742
+weighted avg       0.43      0.44      0.43      5742"""
+
+    return render_template(
+        "classification_reports.html",
+        svm_report=svm_report,
+        rf_report=rf_report,
+        knn_report=knn_report,
+        lr_report=lr_report
+    )
+
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860)

camera.py

@@ -0,0 +1,34 @@
+import cv2
+from model import ERModel
+import numpy as np
+
+facec = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
+model = ERModel("model.json", "model.weights.h5")
+font = cv2.FONT_HERSHEY_SIMPLEX
+
+class VideoCamera(object):
+    def __init__(self):
+        self.video = cv2.VideoCapture(0)
+        # Set camera resolution (smaller size like 320x240)
+        # self.video.set(cv2.CAP_PROP_FRAME_WIDTH, 320)
+        # self.video.set(cv2.CAP_PROP_FRAME_HEIGHT, 240)
+
+    def __del__(self):
+        self.video.release()
+
+    def get_frame(self):
+        _, fr = self.video.read()
+        gray_fr = cv2.cvtColor(fr, cv2.COLOR_BGR2GRAY)
+        faces = facec.detectMultiScale(gray_fr, 1.3, 5)
+
+        for (x, y, w, h) in faces:
+            fc = gray_fr[y:y+h, x:x+w]
+
+            roi = cv2.resize(fc, (48, 48))
+            pred = model.predict_emotion(roi[np.newaxis, :, :, np.newaxis])
+
+            cv2.putText(fr, pred, (x, y), font, 1, (255, 255, 0), 2)
+            cv2.rectangle(fr,(x,y),(x+w,y+h),(255,0,0),2)
+
+        _, jpeg = cv2.imencode('.jpg', fr)
+        return jpeg.tobytes()

clean_requirements.txt

@@ -0,0 +1,93 @@
+absl-py==2.2.2
+astunparse==1.6.3
+blinker==1.9.0
+cachetools==5.5.2
+certifi==2025.1.31
+charset-normalizer==3.4.1
+click==8.1.8
+clip @ git+https://github.com/openai/CLIP.git@dcba3cb2e2827b402d2701e7e1c7d9fed8a20ef1
+colorama==0.4.6
+contourpy==1.3.1
+cycler==0.12.1
+filelock==3.18.0
+Flask==3.1.0
+flask-cors==5.0.1
+flatbuffers==25.2.10
+fonttools==4.57.0
+fsspec==2025.3.2
+ftfy==6.3.1
+gast==0.4.0
+google-auth==2.38.0
+google-auth-oauthlib==1.0.0
+google-pasta==0.2.0
+grpcio==1.71.0
+h5py==3.13.0
+huggingface-hub==0.30.2
+idna==3.10
+imageio==2.37.0
+itsdangerous==2.2.0
+Jinja2==3.1.6
+joblib==1.4.2
+keras==2.15.0
+kiwisolver==1.4.8
+lazy_loader==0.4
+libclang==18.1.1
+Markdown==3.8
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+matplotlib==3.7.2
+mdurl==0.1.2
+ml-dtypes==0.2.0
+mpmath==1.3.0
+namex==0.0.8
+networkx==3.4.2
+numpy==1.26.4
+oauthlib==3.2.2
+opencv-python==4.11.0.86
+opencv-python-headless==4.11.0.86
+opt_einsum==3.4.0
+optree==0.15.0
+packaging==24.2
+pandas==2.2.3
+pillow==11.1.0
+protobuf==4.25.6
+pyasn1==0.6.1
+pyasn1_modules==0.4.2
+Pygments==2.19.1
+pyparsing==3.0.9
+python-dateutil==2.9.0.post0
+pytz==2025.2
+PyYAML==6.0.2
+regex==2024.11.6
+requests==2.31.0
+requests-oauthlib==2.0.0
+rich==14.0.0
+rsa==4.9
+safetensors==0.5.3
+scikit-image==0.25.2
+scikit-learn==1.6.1
+scipy==1.15.2
+seaborn==0.12.2
+six==1.17.0
+sympy==1.13.1
+tensorboard==2.15.2
+tensorboard-data-server==0.7.2
+tensorboard-plugin-wit==1.8.1
+tensorflow==2.15.0
+tensorflow-estimator==2.15.0
+tensorflow-intel==2.15.0
+tensorflow-io-gcs-filesystem==0.31.0
+termcolor==3.0.1
+threadpoolctl==3.6.0
+tifffile==2025.3.30
+tokenizers==0.21.1
+torch==2.1.2
+torchvision==0.16.2
+tqdm==4.67.1
+transformers==4.51.2
+typing_extensions==4.5.0
+tzdata==2025.2
+urllib3==2.4.0
+wcwidth==0.2.13
+Werkzeug==3.1.3
+wrapt==1.14.1

cnn.py

@@ -0,0 +1,52 @@
+import numpy as np
+import cv2
+import base64
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing import image
+import logging
+
+
+# Load model once globally
+model = load_model("emotion_detector_model.h5")
+
+# Constants
+IMG_HEIGHT = 48
+IMG_WIDTH = 48
+TIME_STEPS = 6
+CHUNK_SIZE = 8  # So width 48 -> 6 chunks of 8
+CLASS_NAMES = ['Angry', 'Disgust', 'Fear', 'Happy', 'Sad', 'Surprise', 'Neutral']  # Change based on your dataset
+
+def preprocess_frame(frame):
+    # Convert to grayscale and resize
+    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    resized = cv2.resize(gray, (IMG_WIDTH, IMG_HEIGHT))  # 48x48
+    norm_img = resized / 255.0
+
+    # Split the width into 6 chunks (each 8 pixels wide)
+    chunks = [norm_img[:, i*CHUNK_SIZE:(i+1)*CHUNK_SIZE] for i in range(TIME_STEPS)]
+    sequence = np.stack([chunk[..., np.newaxis] for chunk in chunks], axis=0)  # (6, 48, 8, 1)
+
+    return sequence[np.newaxis, ...]  # shape: (1, 6, 48, 8, 1)
+
+
+def detect_cnn(image_path):
+    # Read image
+    logging.debug(f"Reading image from {image_path}")
+    frame = cv2.imread(image_path)
+    img = image.load_img(image_path, target_size=(48, 48), color_mode='grayscale')
+    img_array = image.img_to_array(img)
+    img_array = np.expand_dims(img_array, axis=0) / 255.0  # Normalize
+
+# ✅ Predict
+    prediction = model.predict(img_array)
+    predicted_class = np.argmax(prediction)
+
+# ✅ Label map (check your training classes to confirm order)
+    class_labels = ['angry', 'disgust', 'fear', 'happy', 'neutral', 'sad', 'surprise']
+
+# ✅ Print result
+    # Encode image to base64 to send back
+    _, buffer = cv2.imencode('.jpg', frame)
+    frame_base64 = base64.b64encode(buffer).decode('utf-8')
+    emotion=class_labels[predicted_class]
+    return emotion,frame_base64

cnn_emotion.py

@@ -0,0 +1,31 @@
+# cnn_emotion.py
+import cv2
+import numpy as np
+import base64
+from model import ERModel
+
+facec = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
+model = ERModel("model.json", "model.weights.h5")
+font = cv2.FONT_HERSHEY_SIMPLEX
+
+def detect_emotion(image_path):
+    fr = cv2.imread(image_path)
+    gray_fr = cv2.cvtColor(fr, cv2.COLOR_BGR2GRAY)
+    faces = facec.detectMultiScale(gray_fr, 1.3, 5)
+
+    final_pred = ""
+    for (x, y, w, h) in faces:
+        fc = gray_fr[y:y+h, x:x+w]
+
+        roi = cv2.resize(fc, (48, 48))
+        pred = model.predict_emotion(roi[np.newaxis, :, :, np.newaxis])
+        final_pred = pred
+
+        cv2.putText(fr, pred, (x, y - 10), font, 0.9, (0, 255, 0), 2)
+        cv2.rectangle(fr, (x, y), (x+w, y+h), (0, 255, 0), 2)
+
+    # Encode image to base64
+    _, buffer = cv2.imencode('.jpg', fr)
+    frame_base64 = base64.b64encode(buffer).decode('utf-8')
+
+    return final_pred, frame_base64

cnn_lstm.py

@@ -0,0 +1,44 @@
+# import cv2
+# import numpy as np
+# from tensorflow.keras.models import load_model
+# from tensorflow.keras.preprocessing.image import img_to_array
+# import base64
+
+# # Load the model once
+# model = load_model("emotion_cnn_lstm.h5")
+
+# # Emotion labels
+# emotion_labels = ['Angry', 'Disgust', 'Fear', 'Happy', 'Neutral', 'Sad', 'Surprise']
+
+# # Load Haar cascade
+# face_classifier = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+
+# def detect_cnn_lstm_emotion(image_path):
+#     frame = cv2.imread(image_path)
+#     gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+
+#     faces = face_classifier.detectMultiScale(gray, scaleFactor=1.3, minNeighbors=5)
+#     print(f"Detected faces: {len(faces)}")
+
+#     final_pred = "No face detected"
+
+#     for (x, y, w, h) in faces:
+#         roi_gray = gray[y:y + h, x:x + w]
+#         roi_gray = cv2.resize(roi_gray, (48, 48))
+#         roi = roi_gray.astype("float") / 255.0
+#         roi = img_to_array(roi)
+#         roi = np.expand_dims(roi, axis=0)
+
+#         prediction = model.predict(roi)[0]
+#         label = emotion_labels[np.argmax(prediction)]
+#         final_pred = label
+
+#         # Draw results on original image
+#         cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 255, 255), 2)
+#         cv2.putText(frame, label, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
+
+#     # Encode frame to base64
+#     _, buffer = cv2.imencode('.jpg', frame)
+#     frame_base64 = base64.b64encode(buffer).decode('utf-8')
+
+#     return final_pred, frame_base64

cnn_resnet.py

@@ -0,0 +1,51 @@
+import numpy as np
+import cv2
+import base64
+from tensorflow.keras.models import load_model
+import logging
+
+
+# Load model once globally
+model = load_model("cnn_rnn_model_from_dir.h5")
+
+# Constants
+IMG_HEIGHT = 48
+IMG_WIDTH = 48
+TIME_STEPS = 6
+CHUNK_SIZE = 8  # So width 48 -> 6 chunks of 8
+CLASS_NAMES = ['Angry', 'Disgust', 'Fear', 'Happy', 'Sad', 'Surprise', 'Neutral']  # Change based on your dataset
+
+def preprocess_frame(frame):
+    # Convert to grayscale and resize
+    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    resized = cv2.resize(gray, (IMG_WIDTH, IMG_HEIGHT))  # 48x48
+    norm_img = resized / 255.0
+
+    # Split the width into 6 chunks (each 8 pixels wide)
+    chunks = [norm_img[:, i*CHUNK_SIZE:(i+1)*CHUNK_SIZE] for i in range(TIME_STEPS)]
+    sequence = np.stack([chunk[..., np.newaxis] for chunk in chunks], axis=0)  # (6, 48, 8, 1)
+
+    return sequence[np.newaxis, ...]  # shape: (1, 6, 48, 8, 1)
+
+
+def detect_cnn_resnetemotion(image_path):
+    # Read image
+    logging.debug(f"Reading image from {image_path}")
+    frame = cv2.imread(image_path)
+    if frame is None:
+        logging.error("Failed to load image.")
+        raise ValueError("Could not read image")
+
+    # Preprocess
+    input_data = preprocess_frame(frame)
+
+    # Predict
+    prediction = model.predict(input_data)
+    predicted_class = int(np.argmax(prediction))
+    emotion = CLASS_NAMES[predicted_class] if predicted_class < len(CLASS_NAMES) else str(predicted_class)
+
+    # Encode image to base64 to send back
+    _, buffer = cv2.imencode('.jpg', frame)
+    frame_base64 = base64.b64encode(buffer).decode('utf-8')
+
+    return emotion, frame_base64

cnn_rnn_model_from_dir.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34427f14fcc055ce73aef33799c94ffd003ea3aa0baa784ca14fd540a4806a49
+size 1904456

comparison.py

@@ -0,0 +1,212 @@
+import os
+import numpy as np
+import torch
+import cv2
+import matplotlib.pyplot as plt
+from sklearn.svm import SVC
+from sklearn.metrics import classification_report, confusion_matrix
+from sklearn.model_selection import train_test_split
+from skimage.feature import hog
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
+from tensorflow.keras.utils import to_categorical
+from tensorflow.keras.preprocessing.image import load_img, img_to_array
+from sklearn.preprocessing import LabelEncoder
+from transformers import CLIPProcessor, CLIPModel
+from transformers import ViTForImageClassification, ViTFeatureExtractor
+from skimage.color import rgb2gray
+from skimage.feature import hog
+import numpy as np
+from PIL import Image
+# ----------------------
+# 1. Load and Preprocess Custom Dataset
+# ----------------------
+
+def load_custom_dataset(dataset_path, image_size=(48, 48)):
+    images = []
+    labels = []
+    label_map = {}
+    label_idx = 0
+
+    # Loop through the dataset folders (each folder is an emotion class)
+    for folder_name in os.listdir(dataset_path):
+        folder_path = os.path.join(dataset_path, folder_name)
+        
+        # Ignore non-directories (i.e., files)
+        if not os.path.isdir(folder_path):
+            continue
+        
+        # Assign an integer label to each emotion
+        if folder_name not in label_map:
+            label_map[folder_name] = label_idx
+            label_idx += 1
+        
+        # Load images and labels
+        for img_name in os.listdir(folder_path):
+            img_path = os.path.join(folder_path, img_name)
+            if img_path.endswith('.jpg') or img_path.endswith('.png'):
+                img = load_img(img_path, target_size=image_size, color_mode='grayscale')
+                img_array = img_to_array(img)
+                images.append(img_array)
+                labels.append(label_map[folder_name])
+
+    # Convert images and labels to numpy arrays
+    images = np.array(images, dtype="float32") / 255.0  # Normalize
+    labels = np.array(labels)
+
+    return images, labels, label_map
+
+dataset_path = 'train'  # Replace with the path to your dataset
+x, y, label_map = load_custom_dataset(dataset_path)
+
+# Print class mapping for reference
+print("Class labels:", label_map)
+
+# ----------------------
+# 2. HOG + SVM (Classical ML)
+# ----------------------
+
+
+
+def extract_hog_features(images):
+    # Check if the image is grayscale (2D) or RGB (3D)
+    # If grayscale (shape (H, W, 1)), squeeze it to (H, W) for processing
+    grayscale_images = [img.squeeze() if len(img.shape) == 3 else img for img in images]
+    
+    # Extract HOG features from grayscale images
+    return np.array([hog(img, pixels_per_cell=(8, 8), cells_per_block=(2, 2)) for img in grayscale_images])
+
+# Assuming your images are already in grayscale, so you can skip rgb2gray for grayscale images.
+
+
+
+# def extract_hog_features(images):
+#     return np.array([hog(img, pixels_per_cell=(8, 8), cells_per_block=(2, 2)) for img in images])
+
+print("[INFO] Extracting HOG features...")
+x_hog = extract_hog_features(x)
+x_train_hog, x_test_hog, y_train_hog, y_test_hog = train_test_split(x_hog, y, test_size=0.2, random_state=42)
+
+print("[INFO] Training SVM classifier...")
+svm = SVC(kernel='linear')
+svm.fit(x_train_hog, y_train_hog)
+y_pred_svm = svm.predict(x_test_hog)
+
+print("\n[RESULTS] SVM Classification Report")
+print(classification_report(y_test_hog, y_pred_svm))
+
+# ----------------------
+# 3. CNN (Deep Learning)
+# ----------------------
+
+y_cnn = to_categorical(y, num_classes=len(label_map))
+x_train_cnn, x_test_cnn, y_train_cnn, y_test_cnn = train_test_split(x, y_cnn, test_size=0.2, random_state=42)
+
+print("[INFO] Building CNN model...")
+cnn = Sequential([
+    Conv2D(32, (3,3), activation='relu', input_shape=(48, 48, 1)),
+    MaxPooling2D(2,2),
+    Conv2D(64, (3,3), activation='relu'),
+    MaxPooling2D(2,2),
+    Flatten(),
+    Dense(128, activation='relu'),
+    Dense(len(label_map), activation='softmax')
+])
+
+cnn.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
+cnn.fit(x_train_cnn, y_train_cnn, epochs=3, batch_size=64, validation_split=0.1)
+
+print("[INFO] Evaluating CNN...")
+loss, acc = cnn.evaluate(x_test_cnn, y_test_cnn)
+print(f"CNN Accuracy: {acc * 100:.2f}%")
+
+# ----------------------
+# 4. CLIP (Vision-Language) Comparison
+# ----------------------
+
+# Load the CLIP model and processor from Huggingface
+clip_model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
+clip_processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
+
+# Example usage of CLIP for image processing
+# image_input = torch.tensor(x[0]).unsqueeze(0)  # Convert to tensor for CLIP input, add batch dimension
+# text_input = ["Emotion description of the image"]  # Provide a text description for comparison
+
+# # Process the inputs with the CLIP processor
+# inputs = clip_processor(text=text_input, images=image_input, return_tensors="pt", padding=True)
+from PIL import Image
+
+# Convert your NumPy grayscale image to a 3-channel RGB PIL image and resize it
+gray_img = (x[0] * 255).astype(np.uint8).squeeze()  # shape: (48, 48)
+rgb_img = np.stack([gray_img]*3, axis=-1)  # Convert to RGB shape: (48, 48, 3)
+pil_img = Image.fromarray(rgb_img).resize((224, 224))  # Resize for CLIP input
+
+# Prepare text input
+text_input = ["Emotion description of the image"]
+
+# Process using CLIPProcessor
+inputs = clip_processor(text=text_input, images=pil_img, return_tensors="pt", padding=True)
+# Get model predictions (outputs)
+outputs = clip_model(**inputs)
+
+# CLIP similarity comparison (text vs image)
+logits_per_image = outputs.logits_per_image  # similarity score
+logits_per_text = outputs.logits_per_text  # similarity score
+
+print("\n[RESULTS] CLIP Similarity Scores")
+print(f"Logits per image: {logits_per_image}")
+print(f"Logits per text: {logits_per_text}")
+
+# ----------------------
+# 5. Vision Transformer (ViT) Comparison
+# ----------------------
+
+# Load ViT model and feature extractor for image classification
+vit_model = ViTForImageClassification.from_pretrained("google/vit-base-patch16-224-in21k")
+vit_feature_extractor = ViTFeatureExtractor.from_pretrained("google/vit-base-patch16-224-in21k")
+
+# Process image and get predictions
+inputs_vit = vit_feature_extractor(x[0], return_tensors="pt")
+outputs_vit = vit_model(**inputs_vit)
+
+print("\n[RESULTS] ViT Classification Scores")
+print(f"ViT logits: {outputs_vit.logits}")
+
+# ----------------------
+# 6. Comparison Results Visualization
+# ----------------------
+
+# Prepare to visualize the comparisons
+plt.figure(figsize=(12, 6))
+
+# Plot Sample Image
+plt.subplot(131)
+plt.title("Sample Image")
+plt.imshow(x[0], cmap='gray')
+
+# Plot HOG Feature Visualization
+plt.subplot(132)
+plt.title("HOG Feature Visualization")
+hog_img = hog(x[0], visualize=True)[1]
+plt.imshow(hog_img, cmap='gray')
+
+# Placeholder for CNN's evaluation
+plt.subplot(133)
+plt.title("CNN Evaluation")
+cnn_img = cnn.predict(np.expand_dims(x[0], axis=0))
+plt.imshow(cnn_img[0], cmap='gray')
+
+plt.show()
+
+# ----------------------
+# 7. Final Model Comparison Summary
+# ----------------------
+
+# You can compare the results side by side in a table or any custom visualization
+print("\n[COMPARISON SUMMARY]")
+print(f"SVM (HOG) Accuracy: {svm.score(x_test_hog, y_test_hog) * 100:.2f}%")
+print(f"CNN Accuracy: {acc * 100:.2f}%")
+
+# CLIP and ViT don't have a direct "accuracy" metric, but you can report similarity scores for CLIP or logits for ViT.
+print(f"CLIP Similarity Score: {logits_per_image}")
+print(f"ViT Logits: {outputs_vit.logits}")

comparison2.py

@@ -0,0 +1,187 @@
+# import os
+# import joblib
+# import json
+# import numpy as np
+# import tensorflow as tf
+# from tqdm import tqdm
+# from skimage.io import imread
+# from skimage.transform import resize
+# from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix
+# from tensorflow.keras.models import model_from_json
+# from transformers import CLIPProcessor, CLIPModel
+# from torchvision import transforms
+# from PIL import Image
+# from sklearn.model_selection import train_test_split
+
+# # ========== Constants ==========
+# IMG_SIZE = 48
+# DATASET_PATH = "train"
+# EMOTIONS = ['angry', 'disgust', 'fear', 'happy', 'sad', 'surprise', 'neutral']
+# MODEL_PATH = ''  # Update with the correct path to your model files
+
+# # ========== Feature Extraction ==========
+# def extract_hog(img):
+#     from skimage.feature import hog
+#     return hog(img, pixels_per_cell=(8, 8), cells_per_block=(2, 2), feature_vector=True)
+
+# def extract_lbp(img):
+#     from skimage.feature import local_binary_pattern
+#     lbp = local_binary_pattern(img, P=8, R=1, method="uniform")
+#     (hist, _) = np.histogram(lbp.ravel(), bins=np.arange(0, 10), range=(0, 9))
+#     hist = hist.astype("float")
+#     hist /= (hist.sum() + 1e-7)
+#     return hist
+
+# def extract_gabor(img):
+#     import cv2
+#     filters = []
+#     ksize = 31
+#     for theta in np.arange(0, np.pi, np.pi / 4):
+#         kernel = cv2.getGaborKernel((ksize, ksize), 4.0, theta, 10.0, 0.5, 0, ktype=cv2.CV_32F)
+#         filters.append(kernel)
+#     feats = [np.mean(cv2.filter2D(img, cv2.CV_8UC3, k)) for k in filters]
+#     return feats
+
+# def extract_features(img):
+#     features = []
+#     features.extend(extract_hog(img))
+#     features.extend(extract_lbp(img))
+#     features.extend(extract_gabor(img))
+#     return features
+
+# # ========== Dataset Loader ==========
+# def load_dataset_features():
+#     X, y = [], []
+#     for label in EMOTIONS:
+#         folder = os.path.join(DATASET_PATH, label)
+#         if not os.path.exists(folder): continue
+#         for file in tqdm(os.listdir(folder), desc=f"Extracting {label}"):
+#             path = os.path.join(folder, file)
+#             try:
+#                 img = imread(path, as_gray=True)
+#                 img = resize(img, (IMG_SIZE, IMG_SIZE), anti_aliasing=True)
+#                 feat = extract_features(img)
+#                 X.append(feat)
+#                 y.append(EMOTIONS.index(label))
+#             except Exception as e:
+#                 print(f"[WARN] Skipped {file}: {e}")
+#     return np.array(X), np.array(y)
+
+# def load_images():
+#     images, labels = [], []
+#     for label in EMOTIONS:
+#         folder = os.path.join(DATASET_PATH, label)
+#         if not os.path.exists(folder): continue
+#         for file in os.listdir(folder):
+#             path = os.path.join(folder, file)
+#             try:
+#                 img = imread(path, as_gray=False)
+#                 img = resize(img, (IMG_SIZE, IMG_SIZE), anti_aliasing=True)
+#                 images.append(img)
+#                 labels.append(EMOTIONS.index(label))
+#             except:
+#                 continue
+#     return np.array(images), np.array(labels)
+
+# # ========== Evaluation Metrics ==========
+# def evaluate_model(y_true, y_pred, model_name):
+#     print(f"\n[RESULTS] {model_name}")
+#     print("Accuracy:", accuracy_score(y_true, y_pred))
+#     print("Precision:", precision_score(y_true, y_pred, average='weighted'))
+#     print("Recall:", recall_score(y_true, y_pred, average='weighted'))
+#     print("F1 Score:", f1_score(y_true, y_pred, average='weighted'))
+#     print("Confusion Matrix:\n", confusion_matrix(y_true, y_pred))
+
+# # ========== Classical Models ==========
+# # def evaluate_classical_models():
+# #     X_test, y_test = load_dataset_features()
+# #     for model_file in ["k-nn_model.joblib", "logistic_regression_model.joblib", "random_forest_model.joblib", "svm_model.joblib"]:
+# #         model = joblib.load(model_file)
+# #         y_pred = model.predict(X_test)
+# #         evaluate_model(y_test, y_pred, model_file)
+
+
+# def evaluate_classical_models():
+#     print("\n[INFO] Evaluating classical ML models...\n")
+#     X, y = load_dataset_features()
+#     X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+#     model_files = {
+#         'KNN': 'k-nn_model.joblib',
+#         'Logistic Regression': 'logistic_regression_model.joblib',
+#         'Random Forest': 'random_forest_model.joblib',
+#         'SVM': 'svm_model.joblib',
+#     }
+
+#     for name, file in model_files.items():
+#         print(f"\n--- {name} ---")
+#         model_path = os.path.join(MODEL_PATH, file)
+#         model = joblib.load(model_path)
+
+#         expected_input_size = model.n_features_in_
+#         if X_test.shape[1] != expected_input_size:
+#             print(f"[WARNING] Feature size mismatch for {name}: "
+#                   f"Expected {expected_input_size}, Got {X_test.shape[1]}. Skipping...")
+#             continue
+
+#         y_pred = model.predict(X_test)
+#         acc = accuracy_score(y_test, y_pred)
+#         prec = precision_score(y_test, y_pred, average='weighted', zero_division=0)
+#         rec = recall_score(y_test, y_pred, average='weighted', zero_division=0)
+#         f1 = f1_score(y_test, y_pred, average='weighted', zero_division=0)
+
+#         print(f"Accuracy: {acc:.4f}")
+#         print(f"Precision: {prec:.4f}")
+#         print(f"Recall: {rec:.4f}")
+#         print(f"F1 Score: {f1:.4f}")
+#         print("Confusion Matrix:")
+#         print(confusion_matrix(y_test, y_pred))
+
+
+# # ========== CNN/RNN Models ==========
+# def evaluate_keras_model(model_path, X_test, y_test, model_name):
+#     model = tf.keras.models.load_model(model_path)
+#     y_pred = np.argmax(model.predict(X_test), axis=1)
+#     evaluate_model(y_test, y_pred, model_name)
+
+# def evaluate_json_model(json_path, weights_path, X_test, y_test, model_name):
+#     with open(json_path, 'r') as f:
+#         model = model_from_json(f.read())
+#     model.load_weights(weights_path)
+#     y_pred = np.argmax(model.predict(X_test), axis=1)
+#     evaluate_model(y_test, y_pred, model_name)
+
+# # ========== ViT/CLIP Model ==========
+# def evaluate_clip_model():
+#     processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
+#     model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
+#     X_test, y_test = load_images()
+#     y_pred = []
+
+#     for i in tqdm(range(len(X_test))):
+#         img = Image.fromarray((X_test[i] * 255).astype(np.uint8))
+#         text = [f"a face showing {emotion} emotion" for emotion in EMOTIONS]
+#         inputs = processor(text=text, images=img, return_tensors="pt", padding=True)
+#         outputs = model(**inputs)
+#         logits_per_image = outputs.logits_per_image
+#         pred = logits_per_image.argmax().item()
+#         y_pred.append(pred)
+
+#     evaluate_model(y_test, y_pred, "ViT-B/32 (CLIP)")
+
+    
+
+# # ========== Run All ==========
+# if __name__ == '__main__':
+#     # evaluate_classical_models()
+
+#     X_raw, y_raw = load_images()
+#     X_raw = X_raw.reshape(-1, IMG_SIZE, IMG_SIZE)
+
+#     # X_raw = X_raw.reshape(-1, IMG_SIZE, IMG_SIZE, 3)
+
+#     evaluate_keras_model("emotion_detector_model.h5", X_raw, y_raw, "CNN Emotion Model")
+#     evaluate_keras_model("cnn_rnn_model_from_dir.h5", X_raw, y_raw, "CNN + RNN Emotion Model")
+#     evaluate_json_model("model_cleaned.json", "model.weights.h5", X_raw, y_raw, "Custom JSON + Weights Model")
+
+#     # evaluate_clip_model()

emotion_detector_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e86e437571b9a100392f8911e913ce395a8f1dad3346dd3ed0e2ab556b47317d
+size 10114720

help.txt

@@ -0,0 +1,34 @@
+python3 -m venv venv
+source venv/bin/activate
+
+# Install dependencies
+pip install --upgrade pip
+pip install -r requirements.txt
+
+
+python app.py
+
+
+flask run --host=0.0.0.0 --port=5000
+
+
+
+
+
+ngrok config add-authtoken 2Pz1X9nABC1234567890abcdefg
+
+
+Authtoken saved to configuration file: /home/ubuntu/.config/ngrok/ngrok.yml
+
+
+ngrok http 7860
+
+
+python app.py --host=0.0.0.0 --port=7860
+
+sudo apt install tmux
+tmux new -s emotionapp
+python app.py --host=0.0.0.0 --port=7860
+ngrok http 7860
+tmux attach -t emotionappNGORK
+

index.html

@@ -0,0 +1,39 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Emotion Detection via ViT</title>
+</head>
+<body>
+  <h2>Webcam Emotion Detector</h2>
+  <video id="video" width="320" height="240" autoplay></video>
+  <canvas id="canvas" width="320" height="240" style="display:none;"></canvas>
+  <p id="emotion"></p>
+  <script>
+    const video = document.getElementById("video");
+    const canvas = document.getElementById("canvas");
+    const context = canvas.getContext("2d");
+    const emotionText = document.getElementById("emotion");
+
+    navigator.mediaDevices.getUserMedia({ video: true }).then(stream => {
+      video.srcObject = stream;
+    });
+
+    setInterval(() => {
+      context.drawImage(video, 0, 0, canvas.width, canvas.height);
+      canvas.toBlob(blob => {
+        const formData = new FormData();
+        formData.append("frame", blob, "frame.jpg");
+
+        fetch("http://127.0.0.1:7860/analyze", {
+          method: "POST",
+          body: formData,
+        })
+        .then(response => response.json())
+        .then(data => {
+          emotionText.textContent = "Detected Emotion: " + data.emotion;
+        });
+      }, "image/jpeg");
+    }, 3000); // every 3 seconds
+  </script>
+</body>
+</html>

k-nn_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:385097ff0871d5669fcdea19e79296c722b800f8dc0f79cf531b75d959c2c8e3
+size 182810196

knn.py

@@ -0,0 +1,35 @@
+import numpy as np
+import cv2
+import base64
+from tensorflow.keras.preprocessing import image
+import logging
+import joblib
+
+# Load KNN model globally
+knn_model = joblib.load('k-nn_model.joblib')
+
+# Emotion classes
+class_labels = ['angry', 'disgust', 'fear', 'happy', 'neutral', 'sad', 'surprise']
+
+def detect_knn(image_path):
+    frame = cv2.imread(image_path)
+    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    resized = cv2.resize(gray, (48, 48))  # 48x48
+    norm_img = resized / 255.0
+
+    # Feature extraction similar to training: horizontal chunks
+    chunks = [norm_img[:, i*8:(i+1)*8] for i in range(6)]  # 6 chunks of 8px
+    sequence = np.stack([chunk.flatten() for chunk in chunks])  # (6, 384)
+    features = sequence.flatten()  # (2304,)
+    features = features[:994]  # match training shape
+
+    features = features.reshape(1, -1)
+
+    prediction = knn_model.predict(features)[0]
+    class_labels = ['angry', 'disgust', 'fear', 'happy', 'neutral', 'sad', 'surprise']
+    emotion = class_labels[prediction]
+
+    _, buffer = cv2.imencode('.jpg', frame)
+    frame_base64 = base64.b64encode(buffer).decode('utf-8')
+
+    return emotion, frame_base64

logistic_regression_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1ec9febd0fbd6a44614a85172d55d18ee0a45a7f0e2962475afb4e1dc6fdbf8d
+size 56623

logisticregression.py

@@ -0,0 +1,35 @@
+import numpy as np
+import cv2
+import base64
+from tensorflow.keras.preprocessing import image
+import logging
+import joblib
+
+# Load KNN model globally
+knn_model = joblib.load('logistic_regression_model.joblib')
+
+# Emotion classes
+class_labels = ['angry', 'disgust', 'fear', 'happy', 'neutral', 'sad', 'surprise']
+
+def detect_lr(image_path):
+    frame = cv2.imread(image_path)
+    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    resized = cv2.resize(gray, (48, 48))  # 48x48
+    norm_img = resized / 255.0
+
+    # Feature extraction similar to training: horizontal chunks
+    chunks = [norm_img[:, i*8:(i+1)*8] for i in range(6)]  # 6 chunks of 8px
+    sequence = np.stack([chunk.flatten() for chunk in chunks])  # (6, 384)
+    features = sequence.flatten()  # (2304,)
+    features = features[:994]  # match training shape
+
+    features = features.reshape(1, -1)
+
+    prediction = knn_model.predict(features)[0]
+    class_labels = ['angry', 'disgust', 'fear', 'happy', 'neutral', 'sad', 'surprise']
+    emotion = class_labels[prediction]
+
+    _, buffer = cv2.imencode('.jpg', frame)
+    frame_base64 = base64.b64encode(buffer).decode('utf-8')
+
+    return emotion, frame_base64

model.json

@@ -0,0 +1 @@
+{"module": "keras", "class_name": "Sequential", "config": {"name": "sequential_12", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "layers": [{"module": "keras.layers", "class_name": "InputLayer", "config": {"batch_shape": [null, 48, 48, 1], "dtype": "float32", "sparse": false, "name": "input_layer_12"}, "registered_name": null}, {"module": "keras.layers", "class_name": "Conv2D", "config": {"name": "conv2d_48", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "filters": 64, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "linear", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "GlorotUniform", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "registered_name": null, "build_config": {"input_shape": [null, 48, 48, 1]}}, {"module": "keras.layers", "class_name": "BatchNormalization", "config": {"name": "batch_normalization_72", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "axis": -1, "momentum": 0.99, "epsilon": 0.001, "center": true, "scale": true, "beta_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "gamma_initializer": {"module": "keras.initializers", "class_name": "Ones", "config": {}, "registered_name": null}, "moving_mean_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "moving_variance_initializer": {"module": "keras.initializers", "class_name": "Ones", "config": {}, "registered_name": null}, "beta_regularizer": null, "gamma_regularizer": null, "beta_constraint": null, "gamma_constraint": null, "synchronized": false}, "registered_name": null, "build_config": {"input_shape": [null, 48, 48, 64]}}, {"module": "keras.layers", "class_name": "Activation", "config": {"name": "activation_72", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "activation": "relu"}, "registered_name": null, "build_config": {"input_shape": [null, 48, 48, 64]}}, {"module": "keras.layers", "class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_48", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "pool_size": [2, 2], "padding": "valid", "strides": [2, 2], "data_format": "channels_last"}, "registered_name": null, "build_config": {"input_shape": [null, 48, 48, 64]}}, {"module": "keras.layers", "class_name": "Dropout", "config": {"name": "dropout_72", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "rate": 0.25, "seed": null, "noise_shape": null}, "registered_name": null, "build_config": {"input_shape": [null, 24, 24, 64]}}, {"module": "keras.layers", "class_name": "Conv2D", "config": {"name": "conv2d_49", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "filters": 128, "kernel_size": [5, 5], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "linear", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "GlorotUniform", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "registered_name": null, "build_config": {"input_shape": [null, 24, 24, 64]}}, {"module": "keras.layers", "class_name": "BatchNormalization", "config": {"name": "batch_normalization_73", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "axis": -1, "momentum": 0.99, "epsilon": 0.001, "center": true, "scale": true, "beta_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "gamma_initializer": {"module": "keras.initializers", "class_name": "Ones", "config": {}, "registered_name": null}, "moving_mean_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "moving_variance_initializer": {"module": "keras.initializers", "class_name": "Ones", "config": {}, "registered_name": null}, "beta_regularizer": null, "gamma_regularizer": null, "beta_constraint": null, "gamma_constraint": null, "synchronized": false}, "registered_name": null, "build_config": {"input_shape": [null, 24, 24, 128]}}, {"module": "keras.layers", "class_name": "Activation", "config": {"name": "activation_73", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "activation": "relu"}, "registered_name": null, "build_config": {"input_shape": [null, 24, 24, 128]}}, {"module": "keras.layers", "class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_49", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "pool_size": [2, 2], "padding": "valid", "strides": [2, 2], "data_format": "channels_last"}, "registered_name": null, "build_config": {"input_shape": [null, 24, 24, 128]}}, {"module": "keras.layers", "class_name": "Dropout", "config": {"name": "dropout_73", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "rate": 0.25, "seed": null, "noise_shape": null}, "registered_name": null, "build_config": {"input_shape": [null, 12, 12, 128]}}, {"module": "keras.layers", "class_name": "Conv2D", "config": {"name": "conv2d_50", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "filters": 256, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "linear", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "GlorotUniform", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "registered_name": null, "build_config": {"input_shape": [null, 12, 12, 128]}}, {"module": "keras.layers", "class_name": "BatchNormalization", "config": {"name": "batch_normalization_74", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "axis": -1, "momentum": 0.99, "epsilon": 0.001, "center": true, "scale": true, "beta_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "gamma_initializer": {"module": "keras.initializers", "class_name": "Ones", "config": {}, "registered_name": null}, "moving_mean_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "moving_variance_initializer": {"module": "keras.initializers", "class_name": "Ones", "config": {}, "registered_name": null}, "beta_regularizer": null, "gamma_regularizer": null, "beta_constraint": null, "gamma_constraint": null, "synchronized": false}, "registered_name": null, "build_config": {"input_shape": [null, 12, 12, 256]}}, {"module": "keras.layers", "class_name": "Activation", "config": {"name": "activation_74", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "activation": "relu"}, "registered_name": null, "build_config": {"input_shape": [null, 12, 12, 256]}}, {"module": "keras.layers", "class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_50", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "pool_size": [2, 2], "padding": "valid", "strides": [2, 2], "data_format": "channels_last"}, "registered_name": null, "build_config": {"input_shape": [null, 12, 12, 256]}}, {"module": "keras.layers", "class_name": "Dropout", "config": {"name": "dropout_74", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "rate": 0.25, "seed": null, "noise_shape": null}, "registered_name": null, "build_config": {"input_shape": [null, 6, 6, 256]}}, {"module": "keras.layers", "class_name": "Conv2D", "config": {"name": "conv2d_51", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "filters": 512, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "linear", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "GlorotUniform", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "registered_name": null, "build_config": {"input_shape": [null, 6, 6, 256]}}, {"module": "keras.layers", "class_name": "BatchNormalization", "config": {"name": "batch_normalization_75", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "axis": -1, "momentum": 0.99, "epsilon": 0.001, "center": true, "scale": true, "beta_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "gamma_initializer": {"module": "keras.initializers", "class_name": "Ones", "config": {}, "registered_name": null}, "moving_mean_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "moving_variance_initializer": {"module": "keras.initializers", "class_name": "Ones", "config": {}, "registered_name": null}, "beta_regularizer": null, "gamma_regularizer": null, "beta_constraint": null, "gamma_constraint": null, "synchronized": false}, "registered_name": null, "build_config": {"input_shape": [null, 6, 6, 512]}}, {"module": "keras.layers", "class_name": "Activation", "config": {"name": "activation_75", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "activation": "relu"}, "registered_name": null, "build_config": {"input_shape": [null, 6, 6, 512]}}, {"module": "keras.layers", "class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_51", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "pool_size": [2, 2], "padding": "valid", "strides": [2, 2], "data_format": "channels_last"}, "registered_name": null, "build_config": {"input_shape": [null, 6, 6, 512]}}, {"module": "keras.layers", "class_name": "Dropout", "config": {"name": "dropout_75", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "rate": 0.25, "seed": null, "noise_shape": null}, "registered_name": null, "build_config": {"input_shape": [null, 3, 3, 512]}}, {"module": "keras.layers", "class_name": "Flatten", "config": {"name": "flatten_12", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "data_format": "channels_last"}, "registered_name": null, "build_config": {"input_shape": [null, 3, 3, 512]}}, {"module": "keras.layers", "class_name": "Dense", "config": {"name": "dense_36", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "units": 256, "activation": "linear", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "GlorotUniform", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "registered_name": null, "build_config": {"input_shape": [null, 4608]}}, {"module": "keras.layers", "class_name": "BatchNormalization", "config": {"name": "batch_normalization_76", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "axis": -1, "momentum": 0.99, "epsilon": 0.001, "center": true, "scale": true, "beta_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "gamma_initializer": {"module": "keras.initializers", "class_name": "Ones", "config": {}, "registered_name": null}, "moving_mean_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "moving_variance_initializer": {"module": "keras.initializers", "class_name": "Ones", "config": {}, "registered_name": null}, "beta_regularizer": null, "gamma_regularizer": null, "beta_constraint": null, "gamma_constraint": null, "synchronized": false}, "registered_name": null, "build_config": {"input_shape": [null, 256]}}, {"module": "keras.layers", "class_name": "Activation", "config": {"name": "activation_76", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "activation": "relu"}, "registered_name": null, "build_config": {"input_shape": [null, 256]}}, {"module": "keras.layers", "class_name": "Dropout", "config": {"name": "dropout_76", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "rate": 0.25, "seed": null, "noise_shape": null}, "registered_name": null, "build_config": {"input_shape": [null, 256]}}, {"module": "keras.layers", "class_name": "Dense", "config": {"name": "dense_37", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "units": 512, "activation": "linear", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "GlorotUniform", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "registered_name": null, "build_config": {"input_shape": [null, 256]}}, {"module": "keras.layers", "class_name": "BatchNormalization", "config": {"name": "batch_normalization_77", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "axis": -1, "momentum": 0.99, "epsilon": 0.001, "center": true, "scale": true, "beta_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "gamma_initializer": {"module": "keras.initializers", "class_name": "Ones", "config": {}, "registered_name": null}, "moving_mean_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "moving_variance_initializer": {"module": "keras.initializers", "class_name": "Ones", "config": {}, "registered_name": null}, "beta_regularizer": null, "gamma_regularizer": null, "beta_constraint": null, "gamma_constraint": null, "synchronized": false}, "registered_name": null, "build_config": {"input_shape": [null, 512]}}, {"module": "keras.layers", "class_name": "Activation", "config": {"name": "activation_77", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "activation": "relu"}, "registered_name": null, "build_config": {"input_shape": [null, 512]}}, {"module": "keras.layers", "class_name": "Dropout", "config": {"name": "dropout_77", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "rate": 0.25, "seed": null, "noise_shape": null}, "registered_name": null, "build_config": {"input_shape": [null, 512]}}, {"module": "keras.layers", "class_name": "Dense", "config": {"name": "dense_38", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "units": 7, "activation": "softmax", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "GlorotUniform", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "registered_name": null, "build_config": {"input_shape": [null, 512]}}], "build_input_shape": [null, 48, 48, 1]}, "registered_name": null, "build_config": {"input_shape": [null, 48, 48, 1]}, "compile_config": {"optimizer": {"module": "keras.optimizers", "class_name": "Adam", "config": {"name": "adam", "learning_rate": 9.999999747378752e-06, "weight_decay": null, "clipnorm": null, "global_clipnorm": null, "clipvalue": null, "use_ema": false, "ema_momentum": 0.99, "ema_overwrite_frequency": null, "loss_scale_factor": null, "gradient_accumulation_steps": null, "beta_1": 0.9, "beta_2": 0.999, "epsilon": 1e-07, "amsgrad": false}, "registered_name": null}, "loss": "sparse_categorical_crossentropy", "loss_weights": null, "metrics": ["accuracy"], "weighted_metrics": null, "run_eagerly": false, "steps_per_execution": 1, "jit_compile": false}}

model.py

@@ -0,0 +1,32 @@
+from tensorflow.keras.models import model_from_json
+from tensorflow.python.keras.backend import set_session
+import numpy as np
+
+import tensorflow as tf
+
+config = tf.compat.v1.ConfigProto()
+config.gpu_options.per_process_gpu_memory_fraction = 0.15
+session = tf.compat.v1.Session(config=config)
+set_session(session)
+
+
+class ERModel(object):
+
+    EMOTIONS_LIST = ["Angry", "Disgust",
+                     "Fear", "Happy",
+                     "Neutral", "Sad",
+                     "Surprise"]
+
+    def __init__(self, model_json_file, model_weights_file):
+
+        with open(model_json_file, "r") as json_file:
+            loaded_model_json = json_file.read()
+            self.loaded_model = model_from_json(loaded_model_json)
+
+        self.loaded_model.load_weights(model_weights_file)
+
+    def predict_emotion(self, img):
+        global session
+        set_session(session)
+        self.preds = self.loaded_model.predict(img)
+        return ERModel.EMOTIONS_LIST[np.argmax(self.preds)]

model.weights.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:67e7e598c46e362929f4d6ccd090e4364459d09ca10f7a5518061ef5c0e35340
+size 36100040

model/clip_emotion.py

@@ -0,0 +1,23 @@
+import torch
+import clip
+from PIL import Image
+import os
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model, preprocess = clip.load("ViT-B/32", device=device)
+
+EMOTION_LABELS = ["happy", "sad", "angry", "surprised", "neutral", "disgusted", "fearful"]
+
+def detect_emotion(image_path):
+    image = preprocess(Image.open(image_path)).unsqueeze(0).to(device)
+    text_inputs = torch.cat([clip.tokenize(f"A face showing {emotion}") for emotion in EMOTION_LABELS]).to(device)
+
+    with torch.no_grad():
+        image_features = model.encode_image(image)
+        text_features = model.encode_text(text_inputs)
+        logits_per_image, _ = model(image, text_inputs)
+        probs = logits_per_image.softmax(dim=-1).cpu().numpy().flatten()
+
+    result = dict(zip(EMOTION_LABELS, probs.tolist()))
+    top_emotion = max(result, key=result.get)
+    return top_emotion, result

model_weights.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f0511939f49907e32eeb49815ce85c963110258263a3b836a195aadc0202de0a
+size 12075696

models/clip_emotion.py

@@ -0,0 +1,38 @@
+import torch
+import clip
+from PIL import Image
+import os
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model, preprocess = clip.load("ViT-B/32", device=device)
+
+EMOTION_LABELS = ["happy", "sad", "angry", "surprised", "neutral", "disgusted", "fearful"]
+AGE_LABELS = [
+    "a child", "a teenager", "a young adult", "a middle-aged person", "an elderly person"
+]
+
+def detect_emotion(image_path):
+    image = preprocess(Image.open(image_path)).unsqueeze(0).to(device)
+    text_inputs = torch.cat([clip.tokenize(f"A face showing {emotion}") for emotion in EMOTION_LABELS]).to(device)
+
+    with torch.no_grad():
+        image_features = model.encode_image(image)
+        text_features = model.encode_text(text_inputs)
+        logits_per_image, _ = model(image, text_inputs)
+        probs = logits_per_image.softmax(dim=-1).cpu().numpy().flatten()
+
+    result = dict(zip(EMOTION_LABELS, probs.tolist()))
+    top_emotion = max(result, key=result.get)
+    return top_emotion, result
+
+def detect_age(image_path):
+    image = preprocess(Image.open(image_path)).unsqueeze(0).to(device)
+    text_inputs = torch.cat([clip.tokenize(f"This is {label}") for label in AGE_LABELS]).to(device)
+
+    with torch.no_grad():
+        logits_per_image, _ = model(image, text_inputs)
+        probs = logits_per_image.softmax(dim=-1).cpu().numpy().flatten()
+
+    result = dict(zip(AGE_LABELS, probs.tolist()))
+    top_age = max(result, key=result.get)
+    return top_age, result

random_forest_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c90e3878501a6d0604642695a545ba089c6fa564e17a5af8266ab1cb46453b1
+size 122485297

randomforest.py

@@ -0,0 +1,35 @@
+import numpy as np
+import cv2
+import base64
+from tensorflow.keras.preprocessing import image
+import logging
+import joblib
+
+# Load KNN model globally
+knn_model = joblib.load('random_forest_model.joblib')
+
+# Emotion classes
+class_labels = ['angry', 'disgust', 'fear', 'happy', 'neutral', 'sad', 'surprise']
+
+def detect_rf(image_path):
+    frame = cv2.imread(image_path)
+    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    resized = cv2.resize(gray, (48, 48))  # 48x48
+    norm_img = resized / 255.0
+
+    # Feature extraction similar to training: horizontal chunks
+    chunks = [norm_img[:, i*8:(i+1)*8] for i in range(6)]  # 6 chunks of 8px
+    sequence = np.stack([chunk.flatten() for chunk in chunks])  # (6, 384)
+    features = sequence.flatten()  # (2304,)
+    features = features[:994]  # match training shape
+
+    features = features.reshape(1, -1)
+
+    prediction = knn_model.predict(features)[0]
+    class_labels = ['angry', 'disgust', 'fear', 'happy', 'neutral', 'sad', 'surprise']
+    emotion = class_labels[prediction]
+
+    _, buffer = cv2.imencode('.jpg', frame)
+    frame_base64 = base64.b64encode(buffer).decode('utf-8')
+
+    return emotion, frame_base64

requirements.txt

@@ -0,0 +1,14 @@
+tensorflow
+torch
+transformers
+opencv-python
+flask
+flask-cors
+Pillow
+ftfy
+regex
+tqdm
+git+https://github.com/openai/CLIP.git
+scikit-image
+joblib
+scikit-learn

static/index.html

@@ -0,0 +1,39 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Emotion Detection</title>
+</head>
+<body>
+  <h2>Webcam Emotion Detector</h2>
+  <video id="video" width="320" height="240" autoplay></video>
+  <canvas id="canvas" width="320" height="240" style="display:none;"></canvas>
+  <p id="emotion"></p>
+  <script>
+    const video = document.getElementById("video");
+    const canvas = document.getElementById("canvas");
+    const context = canvas.getContext("2d");
+    const emotionText = document.getElementById("emotion");
+
+    navigator.mediaDevices.getUserMedia({ video: true }).then(stream => {
+      video.srcObject = stream;
+    });
+
+    setInterval(() => {
+      context.drawImage(video, 0, 0, canvas.width, canvas.height);
+      canvas.toBlob(blob => {
+        const formData = new FormData();
+        formData.append("frame", blob, "frame.jpg");
+
+        fetch("http://127.0.0.1:7860/analyze", {
+          method: "POST",
+          body: formData,
+        })
+        .then(response => response.json())
+        .then(data => {
+          emotionText.textContent = "Detected Emotion: " + data.emotion;
+        });
+      }, "image/jpeg");
+    }, 3000); // every 3 seconds
+  </script>
+</body>
+</html>

svm.py

@@ -0,0 +1,35 @@
+import numpy as np
+import cv2
+import base64
+from tensorflow.keras.preprocessing import image
+import logging
+import joblib
+
+# Load KNN model globally
+knn_model = joblib.load('svm_model.joblib')
+
+# Emotion classes
+class_labels = ['angry', 'disgust', 'fear', 'happy', 'neutral', 'sad', 'surprise']
+
+def detect_svm(image_path):
+    frame = cv2.imread(image_path)
+    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    resized = cv2.resize(gray, (48, 48))  # 48x48
+    norm_img = resized / 255.0
+
+    # Feature extraction similar to training: horizontal chunks
+    chunks = [norm_img[:, i*8:(i+1)*8] for i in range(6)]  # 6 chunks of 8px
+    sequence = np.stack([chunk.flatten() for chunk in chunks])  # (6, 384)
+    features = sequence.flatten()  # (2304,)
+    features = features[:994]  # match training shape
+
+    features = features.reshape(1, -1)
+
+    prediction = knn_model.predict(features)[0]
+    class_labels = ['angry', 'disgust', 'fear', 'happy', 'neutral', 'sad', 'surprise']
+    emotion = class_labels[prediction]
+
+    _, buffer = cv2.imencode('.jpg', frame)
+    frame_base64 = base64.b64encode(buffer).decode('utf-8')
+
+    return emotion, frame_base64

svm_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7132d2c3f1d01003c85fe2411a2322d7a0d3d62056ae5f1b3b5343869ea988f
+size 156484827

templates/classification_reports.html

@@ -0,0 +1,46 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Emotion Recognition Model Reports</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      background-color: #f4f4f4;
+      margin: 0;
+      padding: 2rem;
+    }
+    h1 {
+      text-align: center;
+      color: #333;
+    }
+    h2 {
+      margin-top: 2rem;
+      color: #2c3e50;
+    }
+    pre {
+      background-color: #fff;
+      border-left: 5px solid #007BFF;
+      padding: 1rem;
+      overflow-x: auto;
+      box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+      white-space: pre-wrap;
+    }
+  </style>
+</head>
+<body>
+  <h1>Classification Reports for Emotion Recognition Models</h1>
+
+  <h2>Support Vector Machine (SVM)</h2>
+  <pre>{{ svm_report }}</pre>
+
+  <h2>Random Forest</h2>
+  <pre>{{ rf_report }}</pre>
+
+  <h2>k-Nearest Neighbors (k-NN)</h2>
+  <pre>{{ knn_report }}</pre>
+
+  <h2>Logistic Regression</h2>
+  <pre>{{ lr_report }}</pre>
+</body>
+</html>

templates/cnn.html

@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Emotion Detection via CNN</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      text-align: center;
+    }
+    #video, #canvas {
+      border: 2px solid #444;
+      border-radius: 8px;
+      margin: 10px;
+    }
+    #result {
+      font-size: 18px;
+      font-weight: bold;
+    }
+  </style>
+</head>
+<body>
+  <h2>Webcam Emotion Detector</h2>
+
+  <video id="video" width="320" height="240" autoplay></video>
+  <canvas id="canvas" width="320" height="240" style="display:none;"></canvas>
+
+  <p id="result">Waiting for detection...</p>
+
+  <button onclick="window.location.href='http://127.0.0.1:7860/'">
+    ⬅ Back to Model Selection
+  </button>
+
+  <script>
+    const video = document.getElementById("video");
+    const canvas = document.getElementById("canvas");
+    const context = canvas.getContext("2d");
+    const resultText = document.getElementById("result");
+
+    // Start video stream
+    navigator.mediaDevices.getUserMedia({ video: true }).then(stream => {
+      video.srcObject = stream;
+    });
+
+    setInterval(() => {
+      // Draw current video frame to canvas
+      context.drawImage(video, 0, 0, canvas.width, canvas.height);
+
+      // Convert to blob and send to backend
+      canvas.toBlob(blob => {
+        const formData = new FormData();
+        formData.append("frame", blob, "frame.jpg");
+
+        fetch("http://127.0.0.1:7860/cnn", {
+          method: "POST",
+          body: formData,
+        })
+        .then(response => response.json())
+        .then(data => {
+              resultText.innerHTML = `
+              Detected Emotion: <strong>${data.emotion}</strong><br>
+            `;
+          
+        })
+        .catch(err => {
+          resultText.textContent = "Error: " + err.message;
+        });
+      }, "image/jpeg");
+    }, 300); // Every 3 seconds
+  </script>
+</body>
+</html>

templates/cnn_lstm.html

@@ -0,0 +1,55 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Emotion Detection via ViT</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      text-align: center;
+    }
+    #video, #canvas {
+      border: 2px solid #444;
+      border-radius: 8px;
+      margin: 10px;
+    }
+    #result {
+      font-size: 18px;
+      font-weight: bold;
+    }
+  </style>
+</head>
+<body>
+  <h2>Webcam CNN LSTM Emotion Detector</h2>
+  <video id="video" width="320" height="240" autoplay></video>
+  <canvas id="canvas" width="320" height="240" style="display:none;"></canvas>
+  <p id="emotion">Waiting for detection...</p>
+  <script>
+    const video = document.getElementById("video");
+    const canvas = document.getElementById("canvas");
+    const context = canvas.getContext("2d");
+    const emotionText = document.getElementById("emotion");
+
+    navigator.mediaDevices.getUserMedia({ video: true }).then(stream => {
+      video.srcObject = stream;
+    });
+
+    setInterval(() => {
+      context.drawImage(video, 0, 0, canvas.width, canvas.height);
+      canvas.toBlob(blob => {
+        const formData = new FormData();
+        formData.append("frame", blob, "frame.jpg");
+
+        fetch("http://127.0.0.1:7860/cnn_lstm_video_feed", {
+          method: "POST",
+          body: formData,
+        })
+        .then(response => response.json())
+        .then(data => {
+          emotionText.textContent = "Detected Emotion: " + data.emotion;
+        });
+      }, "image/jpeg");
+    }, 300); // every 3 seconds
+  </script>
+  <button onclick="window.location.href='http://127.0.0.1:7860/'">⬅ Back to Model Selection</button>
+</body>
+</html>

templates/cnn_resnet.html

@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Emotion Detection via CNN + RNN</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      text-align: center;
+    }
+    #video, #canvas {
+      border: 2px solid #444;
+      border-radius: 8px;
+      margin: 10px;
+    }
+    #result {
+      font-size: 18px;
+      font-weight: bold;
+    }
+  </style>
+</head>
+<body>
+  <h2>Webcam Emotion Detector</h2>
+
+  <video id="video" width="320" height="240" autoplay></video>
+  <canvas id="canvas" width="320" height="240" style="display:none;"></canvas>
+
+  <p id="result">Waiting for detection...</p>
+
+  <button onclick="window.location.href='http://127.0.0.1:7860/'">
+    ⬅ Back to Model Selection
+  </button>
+
+  <script>
+    const video = document.getElementById("video");
+    const canvas = document.getElementById("canvas");
+    const context = canvas.getContext("2d");
+    const resultText = document.getElementById("result");
+
+    // Start video stream
+    navigator.mediaDevices.getUserMedia({ video: true }).then(stream => {
+      video.srcObject = stream;
+    });
+
+    setInterval(() => {
+      // Draw current video frame to canvas
+      context.drawImage(video, 0, 0, canvas.width, canvas.height);
+
+      // Convert to blob and send to backend
+      canvas.toBlob(blob => {
+        const formData = new FormData();
+        formData.append("frame", blob, "frame.jpg");
+
+        fetch("http://127.0.0.1:7860/cnn_resnet", {
+          method: "POST",
+          body: formData,
+        })
+        .then(response => response.json())
+        .then(data => {
+              resultText.innerHTML = `
+              Detected Emotion: <strong>${data.emotion}</strong><br>
+            `;
+          
+        })
+        .catch(err => {
+          resultText.textContent = "Error: " + err.message;
+        });
+      }, "image/jpeg");
+    }, 300); // Every 3 seconds
+  </script>
+</body>
+</html>

templates/cnnkeras.html

@@ -0,0 +1,55 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Emotion Detection via ViT</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      text-align: center;
+    }
+    #video, #canvas {
+      border: 2px solid #444;
+      border-radius: 8px;
+      margin: 10px;
+    }
+    #result {
+      font-size: 18px;
+      font-weight: bold;
+    }
+  </style>
+</head>
+<body>
+  <h2>Webcam CNN Keras Emotion Detector</h2>
+  <video id="video" width="320" height="240" autoplay></video>
+  <canvas id="canvas" width="320" height="240" style="display:none;"></canvas>
+  <p id="emotion">Waiting for detection...</p>
+  <script>
+    const video = document.getElementById("video");
+    const canvas = document.getElementById("canvas");
+    const context = canvas.getContext("2d");
+    const emotionText = document.getElementById("emotion");
+
+    navigator.mediaDevices.getUserMedia({ video: true }).then(stream => {
+      video.srcObject = stream;
+    });
+
+    setInterval(() => {
+      context.drawImage(video, 0, 0, canvas.width, canvas.height);
+      canvas.toBlob(blob => {
+        const formData = new FormData();
+        formData.append("frame", blob, "frame.jpg");
+
+        fetch("http://127.0.0.1:7860/video_feed", {
+          method: "POST",
+          body: formData,
+        })
+        .then(response => response.json())
+        .then(data => {
+          emotionText.textContent = "Detected Emotion: " + data.emotion;
+        });
+      }, "image/jpeg");
+    }, 300); // every 3 seconds
+  </script>
+  <button onclick="window.location.href='http://127.0.0.1:7860/'">⬅ Back to Model Selection</button>
+</body>
+</html>

templates/index.html

@@ -0,0 +1,80 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Select Emotion Detection Model</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      text-align: center;
+    }
+    #video, #canvas {
+      border: 2px solid #444;
+      border-radius: 8px;
+      margin: 10px;
+    }
+    #result {
+      font-size: 18px;
+      font-weight: bold;
+    }
+    #reportButton {
+      margin-top: 20px;
+      padding: 10px 20px;
+      font-size: 16px;
+      cursor: pointer;
+    }
+  </style>
+</head>
+<body>
+  <h2>Select Emotion Detection Model</h2>
+
+  <label for="model">Choose Model:</label>
+  <select id="model">
+    <option value="" selected disabled>-- Select Model --</option>
+    <option value="knn">KNN </option>
+    <option value="svm">SVM </option>
+    <option value="rf">Random Forest </option>
+    <option value="lr">Logistic Regression </option>
+    <option value="vit">Vision Transformer (ViT)</option>
+    <option value="cnnkeras">CNN + Keras Tensorflow</option>
+    <option value="cnnonly">CNN</option>
+    <option value="cnnrnn">CNN + RNN </option>
+    <option value="cnnlstm">CNN + LSTM </option>
+  </select>
+
+  <br>
+
+  <!-- Button to call reports -->
+  <button id="reportButton">Show Evaluation Report</button>
+
+  <script>
+    // Model selection redirect
+    document.getElementById("model").addEventListener("change", function () {
+      const model = this.value;
+      if (model === "cnnkeras") {
+        window.location.href = "/cnnkeras";
+      } else if (model === "vit") {
+        window.location.href = "/vit";
+      } else if (model === "cnnlstm") {
+        window.location.href = "/cnnlstm";
+      } else if (model === "cnnrnn") {
+        window.location.href = "/cnn_resnet";
+      } else if (model === "cnnonly") {
+        window.location.href = "/cnn";
+      }else if (model === "knn") {
+        window.location.href = "/knn";
+      }else if (model === "svm") {
+        window.location.href = "/svm";
+      }else if (model === "rf") {
+        window.location.href = "/randomforest";
+      }else if (model === "lr") {
+        window.location.href = "/logistic_regression";
+      }
+    });
+
+    // Button to call /reports endpoint
+    document.getElementById("reportButton").addEventListener("click", function () {
+      window.location.href = "/reports";
+    });
+  </script>
+</body>
+</html>

templates/knn.html

@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Emotion Detection via KNN</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      text-align: center;
+    }
+    #video, #canvas {
+      border: 2px solid #444;
+      border-radius: 8px;
+      margin: 10px;
+    }
+    #result {
+      font-size: 18px;
+      font-weight: bold;
+    }
+  </style>
+</head>
+<body>
+  <h2>Webcam Emotion Detector</h2>
+
+  <video id="video" width="320" height="240" autoplay></video>
+  <canvas id="canvas" width="320" height="240" style="display:none;"></canvas>
+
+  <p id="result">Waiting for detection...</p>
+
+  <button onclick="window.location.href='http://127.0.0.1:7860/'">
+    ⬅ Back to Model Selection
+  </button>
+
+  <script>
+    const video = document.getElementById("video");
+    const canvas = document.getElementById("canvas");
+    const context = canvas.getContext("2d");
+    const resultText = document.getElementById("result");
+
+    // Start video stream
+    navigator.mediaDevices.getUserMedia({ video: true }).then(stream => {
+      video.srcObject = stream;
+    });
+
+    setInterval(() => {
+      // Draw current video frame to canvas
+      context.drawImage(video, 0, 0, canvas.width, canvas.height);
+
+      // Convert to blob and send to backend
+      canvas.toBlob(blob => {
+        const formData = new FormData();
+        formData.append("frame", blob, "frame.jpg");
+
+        fetch("http://127.0.0.1:7860/knn", {
+          method: "POST",
+          body: formData,
+        })
+        .then(response => response.json())
+        .then(data => {
+              resultText.innerHTML = `
+              Detected Emotion: <strong>${data.emotion}</strong><br>
+            `;
+          
+        })
+        .catch(err => {
+          resultText.textContent = "Error: " + err.message;
+        });
+      }, "image/jpeg");
+    }, 300); // Every 3 seconds
+  </script>
+</body>
+</html>

templates/lr.html

@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Emotion Detection via Logistic Regression</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      text-align: center;
+    }
+    #video, #canvas {
+      border: 2px solid #444;
+      border-radius: 8px;
+      margin: 10px;
+    }
+    #result {
+      font-size: 18px;
+      font-weight: bold;
+    }
+  </style>
+</head>
+<body>
+  <h2>Webcam Emotion Detector</h2>
+
+  <video id="video" width="320" height="240" autoplay></video>
+  <canvas id="canvas" width="320" height="240" style="display:none;"></canvas>
+
+  <p id="result">Waiting for detection...</p>
+
+  <button onclick="window.location.href='http://127.0.0.1:7860/'">
+    ⬅ Back to Model Selection
+  </button>
+
+  <script>
+    const video = document.getElementById("video");
+    const canvas = document.getElementById("canvas");
+    const context = canvas.getContext("2d");
+    const resultText = document.getElementById("result");
+
+    // Start video stream
+    navigator.mediaDevices.getUserMedia({ video: true }).then(stream => {
+      video.srcObject = stream;
+    });
+
+    setInterval(() => {
+      // Draw current video frame to canvas
+      context.drawImage(video, 0, 0, canvas.width, canvas.height);
+
+      // Convert to blob and send to backend
+      canvas.toBlob(blob => {
+        const formData = new FormData();
+        formData.append("frame", blob, "frame.jpg");
+
+        fetch("http://127.0.0.1:7860/logistic_regression", {
+          method: "POST",
+          body: formData,
+        })
+        .then(response => response.json())
+        .then(data => {
+              resultText.innerHTML = `
+              Detected Emotion: <strong>${data.emotion}</strong><br>
+            `;
+          
+        })
+        .catch(err => {
+          resultText.textContent = "Error: " + err.message;
+        });
+      }, "image/jpeg");
+    }, 300); // Every 3 seconds
+  </script>
+</body>
+</html>

templates/rf.html

@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Emotion Detection via Random Forest</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      text-align: center;
+    }
+    #video, #canvas {
+      border: 2px solid #444;
+      border-radius: 8px;
+      margin: 10px;
+    }
+    #result {
+      font-size: 18px;
+      font-weight: bold;
+    }
+  </style>
+</head>
+<body>
+  <h2>Webcam Emotion Detector</h2>
+
+  <video id="video" width="320" height="240" autoplay></video>
+  <canvas id="canvas" width="320" height="240" style="display:none;"></canvas>
+
+  <p id="result">Waiting for detection...</p>
+
+  <button onclick="window.location.href='http://127.0.0.1:7860/'">
+    ⬅ Back to Model Selection
+  </button>
+
+  <script>
+    const video = document.getElementById("video");
+    const canvas = document.getElementById("canvas");
+    const context = canvas.getContext("2d");
+    const resultText = document.getElementById("result");
+
+    // Start video stream
+    navigator.mediaDevices.getUserMedia({ video: true }).then(stream => {
+      video.srcObject = stream;
+    });
+
+    setInterval(() => {
+      // Draw current video frame to canvas
+      context.drawImage(video, 0, 0, canvas.width, canvas.height);
+
+      // Convert to blob and send to backend
+      canvas.toBlob(blob => {
+        const formData = new FormData();
+        formData.append("frame", blob, "frame.jpg");
+
+        fetch("http://127.0.0.1:7860/randomforest", {
+          method: "POST",
+          body: formData,
+        })
+        .then(response => response.json())
+        .then(data => {
+              resultText.innerHTML = `
+              Detected Emotion: <strong>${data.emotion}</strong><br>
+            `;
+          
+        })
+        .catch(err => {
+          resultText.textContent = "Error: " + err.message;
+        });
+      }, "image/jpeg");
+    }, 300); // Every 3 seconds
+  </script>
+</body>
+</html>

templates/svm.html

@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Emotion Detection via SVM</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      text-align: center;
+    }
+    #video, #canvas {
+      border: 2px solid #444;
+      border-radius: 8px;
+      margin: 10px;
+    }
+    #result {
+      font-size: 18px;
+      font-weight: bold;
+    }
+  </style>
+</head>
+<body>
+  <h2>Webcam Emotion Detector</h2>
+
+  <video id="video" width="320" height="240" autoplay></video>
+  <canvas id="canvas" width="320" height="240" style="display:none;"></canvas>
+
+  <p id="result">Waiting for detection...</p>
+
+  <button onclick="window.location.href='http://127.0.0.1:7860/'">
+    ⬅ Back to Model Selection
+  </button>
+
+  <script>
+    const video = document.getElementById("video");
+    const canvas = document.getElementById("canvas");
+    const context = canvas.getContext("2d");
+    const resultText = document.getElementById("result");
+
+    // Start video stream
+    navigator.mediaDevices.getUserMedia({ video: true }).then(stream => {
+      video.srcObject = stream;
+    });
+
+    setInterval(() => {
+      // Draw current video frame to canvas
+      context.drawImage(video, 0, 0, canvas.width, canvas.height);
+
+      // Convert to blob and send to backend
+      canvas.toBlob(blob => {
+        const formData = new FormData();
+        formData.append("frame", blob, "frame.jpg");
+
+        fetch("http://127.0.0.1:7860/svm", {
+          method: "POST",
+          body: formData,
+        })
+        .then(response => response.json())
+        .then(data => {
+              resultText.innerHTML = `
+              Detected Emotion: <strong>${data.emotion}</strong><br>
+            `;
+          
+        })
+        .catch(err => {
+          resultText.textContent = "Error: " + err.message;
+        });
+      }, "image/jpeg");
+    }, 300); // Every 3 seconds
+  </script>
+</body>
+</html>

templates/vit.html

@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Emotion & Age Detection via ViT</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      text-align: center;
+    }
+    #video, #canvas {
+      border: 2px solid #444;
+      border-radius: 8px;
+      margin: 10px;
+    }
+    #result {
+      font-size: 18px;
+      font-weight: bold;
+    }
+  </style>
+</head>
+<body>
+  <h2>Webcam Emotion & Age Detector</h2>
+
+  <video id="video" width="320" height="240" autoplay></video>
+  <canvas id="canvas" width="320" height="240" style="display:none;"></canvas>
+
+  <p id="result">Waiting for detection...</p>
+
+  <button onclick="window.location.href='http://127.0.0.1:7860/'">
+    ⬅ Back to Model Selection
+  </button>
+
+  <script>
+    const video = document.getElementById("video");
+    const canvas = document.getElementById("canvas");
+    const context = canvas.getContext("2d");
+    const resultText = document.getElementById("result");
+
+    // Start video stream
+    navigator.mediaDevices.getUserMedia({ video: true }).then(stream => {
+      video.srcObject = stream;
+    });
+
+    setInterval(() => {
+      // Draw current video frame to canvas
+      context.drawImage(video, 0, 0, canvas.width, canvas.height);
+
+      // Convert to blob and send to backend
+      canvas.toBlob(blob => {
+        const formData = new FormData();
+        formData.append("frame", blob, "frame.jpg");
+
+        fetch("http://127.0.0.1:7860/analyze", {
+          method: "POST",
+          body: formData,
+        })
+        .then(response => response.json())
+        .then(data => {
+              resultText.innerHTML = `
+              Detected Emotion: <strong>${data.emotion}</strong><br>
+              Estimated Age Group: <strong>${data.age}</strong>
+            `;
+          
+        })
+        .catch(err => {
+          resultText.textContent = "Error: " + err.message;
+        });
+      }, "image/jpeg");
+    }, 300); // Every 3 seconds
+  </script>
+</body>
+</html>

testing.py

@@ -0,0 +1,5 @@
+
+import tensorflow as tf
+import keras
+print("TensorFlow:", tf.__version__)
+print("Keras:", keras.__version__)

train_basic_ml.py

@@ -0,0 +1,102 @@
+# Classical ML Emotion Detection with HOG, LBP, Gabor (NumPy 2.x Compatible - OpenCV Removed)
+
+import numpy as np
+from skimage.io import imread
+from skimage.transform import resize
+from skimage.feature import hog, local_binary_pattern
+from skimage.filters import gabor
+from sklearn.model_selection import train_test_split
+from sklearn.svm import SVC
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import classification_report
+import os
+from tqdm import tqdm
+import joblib  # Import joblib for saving models
+
+# ----------------------
+# Configuration
+# ----------------------
+IMG_SIZE = 48
+DATASET_PATH = "./train"  # Folder structure: ./dataset/<label>/<image>.jpg
+EMOTIONS = ['angry', 'disgust', 'fear', 'happy', 'neutral', 'sad', 'surprise']
+
+# ----------------------
+# Feature Extraction Functions
+# ----------------------
+def extract_hog(img):
+    return hog(img, pixels_per_cell=(8, 8), cells_per_block=(2, 2))
+
+def extract_lbp(img):
+    lbp = local_binary_pattern(img, P=8, R=1, method="uniform")
+    (hist, _) = np.histogram(lbp.ravel(), bins=np.arange(0, 59))
+    hist = hist.astype("float")
+    hist /= (hist.sum() + 1e-6)
+    return hist
+
+def extract_gabor(img):
+    filt_real, _ = gabor(img, frequency=0.6)
+    return filt_real.ravel()[::64]  # downsample to reduce dimensionality
+
+# ----------------------
+# Load Dataset and Extract Features
+# ----------------------
+def load_dataset():
+    data = []
+    labels = []
+    print("[INFO] Loading dataset and extracting features...")
+
+    for label in EMOTIONS:
+        folder = os.path.join(DATASET_PATH, label)
+        if not os.path.exists(folder):
+            continue
+        for file in tqdm(os.listdir(folder), desc=label):
+            path = os.path.join(folder, file)
+            try:
+                img = imread(path, as_gray=True)
+                img = resize(img, (IMG_SIZE, IMG_SIZE), anti_aliasing=True)
+            except Exception as e:
+                print(f"[WARNING] Skipped {file}: {e}")
+                continue
+
+            feat = []
+            feat.extend(extract_hog(img))
+            feat.extend(extract_lbp(img))
+            feat.extend(extract_gabor(img))
+
+            data.append(feat)
+            labels.append(EMOTIONS.index(label))
+
+    return np.array(data), np.array(labels)
+
+# ----------------------
+# Train & Evaluate Models
+# ----------------------
+def train_and_evaluate(X, y):
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+    classifiers = {
+        "SVM": SVC(kernel='linear'),
+        "Random Forest": RandomForestClassifier(n_estimators=100),
+        "k-NN": KNeighborsClassifier(n_neighbors=5),
+        "Logistic Regression": LogisticRegression(max_iter=1000)
+    }
+
+    for name, clf in classifiers.items():
+        print(f"\n[INFO] Training {name}...")
+        clf.fit(X_train, y_train)
+        preds = clf.predict(X_test)
+        print(f"\n[RESULTS] {name} Classification Report")
+        print(classification_report(y_test, preds, target_names=EMOTIONS))
+        # Save the trained model using joblib
+        model_filename = f'{name.lower().replace(" ", "_")}_model.joblib'
+        print(f"[INFO] Saving {name} model to {model_filename}...")
+        joblib.dump(clf, model_filename)
+
+# ----------------------
+# Run Full Pipeline
+# ----------------------
+if __name__ == "__main__":
+    X, y = load_dataset()
+    train_and_evaluate(X, y)

train_cnn_rnn_fer2013.py

@@ -0,0 +1,83 @@
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Conv2D, MaxPooling2D, TimeDistributed, Flatten, Dense, Dropout, SimpleRNN
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+import os
+
+# Constants
+img_height, img_width = 48, 48
+channels = 1
+batch_size = 64
+time_steps = 6
+chunk_size = 8  # 6 chunks of width 8 to match 48 width
+
+# Paths
+train_dir = 'train'
+test_dir = 'test'
+
+# Image Generators (no augmentation for now)
+train_datagen = ImageDataGenerator(rescale=1./255)
+test_datagen = ImageDataGenerator(rescale=1./255)
+
+# Load images from directories
+train_generator = train_datagen.flow_from_directory(
+    train_dir,
+    target_size=(img_height, img_width),
+    color_mode='grayscale',
+    class_mode='categorical',
+    batch_size=batch_size,
+    shuffle=True
+)
+
+test_generator = test_datagen.flow_from_directory(
+    test_dir,
+    target_size=(img_height, img_width),
+    color_mode='grayscale',
+    class_mode='categorical',
+    batch_size=batch_size,
+    shuffle=False
+)
+
+# Helper: Reshape batches to (samples, time_steps, height, chunk_size, 1)
+def reshape_batch(batch_x):
+    return batch_x.reshape(-1, time_steps, img_height, chunk_size, 1)
+
+# Build CNN + RNN Model
+model = Sequential()
+model.add(TimeDistributed(Conv2D(32, (3, 3), activation='relu'), input_shape=(time_steps, img_height, chunk_size, 1)))
+model.add(TimeDistributed(MaxPooling2D(pool_size=(2, 2))))
+model.add(TimeDistributed(Flatten()))
+model.add(SimpleRNN(64))
+model.add(Dense(128, activation='relu'))
+model.add(Dropout(0.5))
+model.add(Dense(train_generator.num_classes, activation='softmax'))
+
+model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
+model.summary()
+
+# Custom training loop to reshape batches for CNN + RNN
+epochs = 10
+steps_per_epoch = train_generator.samples // batch_size
+validation_steps = test_generator.samples // batch_size
+
+for epoch in range(epochs):
+    print(f"\nEpoch {epoch+1}/{epochs}")
+    for step in range(steps_per_epoch):
+        batch_x, batch_y = next(train_generator)
+        batch_x_rnn = reshape_batch(batch_x)
+        model.train_on_batch(batch_x_rnn, batch_y)
+
+    # Validation
+    val_accuracy = []
+    val_loss = []
+    for _ in range(validation_steps):
+        val_x, val_y = next(test_generator)
+        val_x_rnn = reshape_batch(val_x)
+        loss, acc = model.evaluate(val_x_rnn, val_y, verbose=0)
+        val_accuracy.append(acc)
+        val_loss.append(loss)
+    print(f"Validation Loss: {np.mean(val_loss):.4f}, Accuracy: {np.mean(val_accuracy):.4f}")
+
+# Save model
+model.save("cnn_rnn_model_from_dir.h5")