Upload 32 files

app.py

@@ -9,6 +9,10 @@ from cnn_emotion import detect_emotion as detect_emotion_cnn
 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
 
@@ -29,6 +33,21 @@ os.makedirs(UPLOAD_FOLDER, exist_ok=True)
 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():
@@ -136,5 +155,132 @@ def cnn():
         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)

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

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()

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

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

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

@@ -11,3 +11,4 @@ tqdm
 git+https://github.com/openai/CLIP.git
 scikit-image
 joblib
+scikit-learn

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