Update train cnn to improve accuracy

01-crop_faces_with_mtcnn.py

@@ -1,8 +1,7 @@
 import cv2
 from mtcnn import MTCNN
 import csv
-import sys, os.path
-from keras import backend as K
+import os
 import tensorflow as tf
 print(tf.__version__)
 tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)

02-prepare_fake_real_dataset.py

@@ -1,7 +1,6 @@
 import csv
 import os
 import shutil
-import numpy as np
 import splitfolders as split_folders
 from PIL import Image
 

03-train_cnn.py

@@ -1,36 +1,18 @@
-import json
 import os
-from distutils.dir_util import copy_tree
-import shutil
 import pandas as pd
+import numpy as np
 
 # TensorFlow and tf.keras
 import tensorflow as tf
-from tensorflow.keras import backend as K
 print('TensorFlow version: ', tf.__version__)
 
-# Set to force CPU
-#os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
-#if tf.test.gpu_device_name():
-#    print('GPU found')
-#else:
-#    print("No GPU found")
-
 dataset_path = '.\\split_dataset\\'
 
 tmp_debug_path = '.\\tmp_debug'
 print('Creating Directory: ' + tmp_debug_path)
 os.makedirs(tmp_debug_path, exist_ok=True)
 
-def get_filename_only(file_path):
-    file_basename = os.path.basename(file_path)
-    filename_only = file_basename.split('.')[0]
-    return filename_only
-
-import numpy as np
-from sklearn.utils.class_weight import compute_class_weight
 from tensorflow.keras.preprocessing.image import ImageDataGenerator
-from tensorflow.keras import applications
 from tensorflow.keras.applications import EfficientNetB0
 from tensorflow.keras.applications.efficientnet import preprocess_input
 from tensorflow.keras.models import Sequential, load_model
@@ -44,16 +26,12 @@ train_path = os.path.join(dataset_path, 'train')
 val_path = os.path.join(dataset_path, 'val')
 test_path = os.path.join(dataset_path, 'test')
 
+# preprocess_input scales pixels to [-1, 1] which EfficientNet expects
 train_datagen = ImageDataGenerator(
     preprocessing_function = preprocess_input,
-    rotation_range = 15,
-    width_shift_range = 0.15,
-    height_shift_range = 0.15,
-    shear_range = 0.2,
-    zoom_range = 0.15,
+    rotation_range = 10,
     horizontal_flip = True,
-    brightness_range = [0.8, 1.2],
-    channel_shift_range = 30,
+    zoom_range = 0.1,
     fill_mode = 'nearest'
 )
 
@@ -66,11 +44,7 @@ train_generator = train_datagen.flow_from_directory(
     shuffle = True
 )
 
-# Compute class weights to handle imbalance
-class_weights = compute_class_weight('balanced', classes=np.unique(train_generator.classes), y=train_generator.classes)
-class_weight_dict = dict(enumerate(class_weights))
 print(f'Class mapping: {train_generator.class_indices}')
-print(f'Class weights: {class_weight_dict}')
 print(f'Train samples - fake: {np.sum(train_generator.classes == 0)}, real: {np.sum(train_generator.classes == 1)}')
 
 val_datagen = ImageDataGenerator(
@@ -100,110 +74,61 @@ test_generator = test_datagen.flow_from_directory(
     shuffle = False
 )
 
-# --- Phase 1: Train with frozen base ---
+# Build model - entire EfficientNetB0 is trainable
 efficient_net = EfficientNetB0(
     weights = 'imagenet',
     input_shape = (input_size, input_size, 3),
     include_top = False,
     pooling = 'max'
 )
-efficient_net.trainable = False  # freeze base initially
 
 model = Sequential()
 model.add(efficient_net)
 model.add(Dense(units = 512, activation = 'relu'))
 model.add(Dropout(0.5))
 model.add(Dense(units = 128, activation = 'relu'))
-model.add(Dropout(0.3))
 model.add(Dense(units = 1, activation = 'sigmoid'))
 model.summary()
 
-model.compile(optimizer = Adam(learning_rate=0.0001), loss='binary_crossentropy', metrics=['accuracy'])
+model.compile(optimizer = Adam(learning_rate=1e-4), loss='binary_crossentropy', metrics=['accuracy'])
 
 checkpoint_filepath = '.\\tmp_checkpoint'
 print('Creating Directory: ' + checkpoint_filepath)
 os.makedirs(checkpoint_filepath, exist_ok=True)
 
-custom_callbacks = [
+callbacks = [
     EarlyStopping(
-        monitor = 'val_accuracy',
-        mode = 'max',
+        monitor = 'val_loss',
+        mode = 'min',
         patience = 5,
         verbose = 1,
         restore_best_weights = True
     ),
     ModelCheckpoint(
         filepath = os.path.join(checkpoint_filepath, 'best_model.keras'),
-        monitor = 'val_accuracy',
-        mode = 'max',
+        monitor = 'val_loss',
+        mode = 'min',
         verbose = 1,
         save_best_only = True
     ),
     ReduceLROnPlateau(
-        monitor = 'val_accuracy',
+        monitor = 'val_loss',
         factor = 0.5,
         patience = 3,
         min_lr = 1e-7,
-        verbose = 1,
-        mode = 'max'
+        verbose = 1
     )
 ]
 
-print('\n=== Phase 1: Training with frozen base ===')
-num_epochs = 15
+print('\n=== Training ===')
+num_epochs = 20
 history = model.fit(
     train_generator,
     epochs = num_epochs,
     steps_per_epoch = len(train_generator),
     validation_data = val_generator,
     validation_steps = len(val_generator),
-    callbacks = custom_callbacks,
-    class_weight = class_weight_dict
-)
-
-# --- Phase 2: Fine-tune top layers of base model ---
-print('\n=== Phase 2: Fine-tuning top layers ===')
-efficient_net.trainable = True
-# Freeze all layers except the last 30
-for layer in efficient_net.layers[:-30]:
-    layer.trainable = False
-
-model.compile(optimizer = Adam(learning_rate=1e-5), loss='binary_crossentropy', metrics=['accuracy'])
-
-fine_tune_callbacks = [
-    EarlyStopping(
-        monitor = 'val_accuracy',
-        mode = 'max',
-        patience = 5,
-        verbose = 1,
-        restore_best_weights = True
-    ),
-    ModelCheckpoint(
-        filepath = os.path.join(checkpoint_filepath, 'best_model.keras'),
-        monitor = 'val_accuracy',
-        mode = 'max',
-        verbose = 1,
-        save_best_only = True
-    ),
-    ReduceLROnPlateau(
-        monitor = 'val_accuracy',
-        factor = 0.5,
-        patience = 3,
-        min_lr = 1e-8,
-        verbose = 1,
-        mode = 'max'
-    )
-]
-
-fine_tune_epochs = 30
-history_fine = model.fit(
-    train_generator,
-    epochs = fine_tune_epochs,
-    steps_per_epoch = len(train_generator),
-    validation_data = val_generator,
-    validation_steps = len(val_generator),
-    callbacks = fine_tune_callbacks,
-    class_weight = class_weight_dict
+    callbacks = callbacks
 )
 
 # Load the best model
@@ -213,8 +138,6 @@ best_model = load_model(os.path.join(checkpoint_filepath, 'best_model.keras'))
 print('\n=== Evaluation on Test Set ===')
 test_generator.reset()
 test_loss, test_accuracy = best_model.evaluate(test_generator, steps=len(test_generator), verbose=1)
-print(f'Test Loss: {test_loss:.4f}')
-print(f'Test Accuracy: {test_accuracy:.4f}')
 
 # Generate predictions
 test_generator.reset()
@@ -222,11 +145,31 @@ preds = best_model.predict(test_generator, verbose=1)
 pred_labels = (preds.flatten() > 0.5).astype(int)
 true_labels = test_generator.classes
 
-from sklearn.metrics import classification_report, confusion_matrix
+from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
+
+overall_accuracy = accuracy_score(true_labels, pred_labels)
+cm = confusion_matrix(true_labels, pred_labels)
+
+print(f'\n{"="*60}')
+print(f'  MODEL ACCURACY REPORT')
+print(f'{"="*60}')
+print(f'  Overall Accuracy:  {overall_accuracy:.4f} ({overall_accuracy*100:.2f}%)')
+print(f'  Test Loss:         {test_loss:.4f}')
+print(f'{"="*60}')
+
+# Per-class accuracy
+fake_correct = cm[0][0]
+fake_total = cm[0].sum()
+real_correct = cm[1][1]
+real_total = cm[1].sum()
+print(f'  Fake  Accuracy:    {fake_correct}/{fake_total} = {fake_correct/fake_total:.4f} ({fake_correct/fake_total*100:.2f}%)')
+print(f'  Real  Accuracy:    {real_correct}/{real_total} = {real_correct/real_total:.4f} ({real_correct/real_total*100:.2f}%)')
+print(f'{"="*60}')
+
 print('\nClassification Report:')
 print(classification_report(true_labels, pred_labels, target_names=['fake', 'real']))
 print('Confusion Matrix:')
-print(confusion_matrix(true_labels, pred_labels))
+print(cm)
 
 test_results = pd.DataFrame({
     "Filename": test_generator.filenames,

App/app.py

@@ -1,6 +1,4 @@
 import os
-import sys
-import io
 import base64
 import math
 import logging
@@ -13,7 +11,6 @@ from flask import Flask, request, render_template, send_from_directory, jsonify
 from werkzeug.utils import secure_filename
 import uuid
 import threading
-import tensorflow as tf
 from tensorflow.keras.models import load_model
 
 logging.basicConfig(
@@ -30,13 +27,10 @@ ALLOWED_EXTENSIONS = {'mp4', 'avi', 'mov', 'mkv', 'wmv'}
 
 os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
 
-# Load the trained model (suppress lz4 I/O warnings)
-MODEL_PATH = os.path.join(os.path.dirname(__file__), '..', 'tmp_checkpoint', 'best_model.h5')
+# Load the trained model
+MODEL_PATH = os.path.join(os.path.dirname(__file__), '..', 'tmp_checkpoint', 'best_model.keras')
 logger.info('Loading model from %s', MODEL_PATH)
-_stderr = sys.stderr
-sys.stderr = io.StringIO()
 model = load_model(MODEL_PATH)
-sys.stderr = _stderr
 logger.info('Model loaded successfully')
 INPUT_SIZE = 128
 

App/blaze_face_short_range.tflite

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