Initial the project

.gitignore

@@ -0,0 +1,138 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+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/
+
+# 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
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.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
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__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/
+
+#temp dataset folders
+tmp_*/
+mtcnn/
+/.conda
+/train_sample_videos
+/split_dataset
+/prepared_dataset
+/App/uploads

00-convert_video_to_image.py

@@ -0,0 +1,57 @@
+import json
+import os
+import cv2
+import math
+
+base_path = '.\\train_sample_videos\\'
+
+def get_filename_only(file_path):
+    file_basename = os.path.basename(file_path)
+    filename_only = file_basename.split('.')[0]
+    return filename_only
+
+with open(os.path.join(base_path, 'metadata.json')) as metadata_json:
+    metadata = json.load(metadata_json)
+    print(len(metadata))
+
+for filename in metadata.keys():
+    print(filename)
+    if (filename.endswith(".mp4")):
+        tmp_path = os.path.join(base_path, get_filename_only(filename))
+        print('Creating Directory: ' + tmp_path)
+        os.makedirs(tmp_path, exist_ok=True)
+        print('Converting Video to Images...')
+        count = 0
+        video_file = os.path.join(base_path, filename)
+        cap = cv2.VideoCapture(video_file)
+        frame_rate = cap.get(5) #frame rate
+        while(cap.isOpened()):
+            frame_id = cap.get(1) #current frame number
+            ret, frame = cap.read()
+            if (ret != True):
+                break
+            if (frame_id % math.floor(frame_rate) == 0):
+                print('Original Dimensions: ', frame.shape)
+                if frame.shape[1] < 300:
+                    scale_ratio = 2
+                elif frame.shape[1] > 1900:
+                    scale_ratio = 0.33
+                elif frame.shape[1] > 1000 and frame.shape[1] <= 1900 :
+                    scale_ratio = 0.5
+                else:
+                    scale_ratio = 1
+                print('Scale Ratio: ', scale_ratio)
+
+                width = int(frame.shape[1] * scale_ratio)
+                height = int(frame.shape[0] * scale_ratio)
+                dim = (width, height)
+                new_frame = cv2.resize(frame, dim, interpolation = cv2.INTER_AREA)
+                print('Resized Dimensions: ', new_frame.shape)
+
+                new_filename = '{}-{:03d}.png'.format(os.path.join(tmp_path, get_filename_only(filename)), count)
+                count = count + 1
+                cv2.imwrite(new_filename, new_frame)
+        cap.release()
+        print("Done!")
+    else:
+        continue

01a-crop_faces_with_mtcnn.py

@@ -0,0 +1,70 @@
+import cv2
+from mtcnn import MTCNN
+import sys, os.path
+import json
+from keras import backend as K
+import tensorflow as tf
+print(tf.__version__)
+tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)
+
+physical_devices = tf.config.list_physical_devices('GPU')
+print(physical_devices)
+if physical_devices:
+    tf.config.experimental.set_memory_growth(physical_devices[0], True)
+
+base_path = '.\\train_sample_videos\\'
+
+def get_filename_only(file_path):
+    file_basename = os.path.basename(file_path)
+    filename_only = file_basename.split('.')[0]
+    return filename_only
+
+with open(os.path.join(base_path, 'metadata.json')) as metadata_json:
+    metadata = json.load(metadata_json)
+    print(len(metadata))
+
+for filename in metadata.keys():
+    tmp_path = os.path.join(base_path, get_filename_only(filename))
+    print('Processing Directory: ' + tmp_path)
+    frame_images = [x for x in os.listdir(tmp_path) if os.path.isfile(os.path.join(tmp_path, x))]
+    faces_path = os.path.join(tmp_path, 'faces')
+    print('Creating Directory: ' + faces_path)
+    os.makedirs(faces_path, exist_ok=True)
+    print('Cropping Faces from Images...')
+
+    for frame in frame_images:
+        print('Processing ', frame)
+        detector = MTCNN()
+        image = cv2.cvtColor(cv2.imread(os.path.join(tmp_path, frame)), cv2.COLOR_BGR2RGB)
+        results = detector.detect_faces(image)
+        print('Face Detected: ', len(results))
+        count = 0
+        
+        for result in results:
+            bounding_box = result['box']
+            print(bounding_box)
+            confidence = result['confidence']
+            print(confidence)
+            if len(results) < 2 or confidence > 0.95:
+                margin_x = bounding_box[2] * 0.3  # 30% as the margin
+                margin_y = bounding_box[3] * 0.3  # 30% as the margin
+                x1 = int(bounding_box[0] - margin_x)
+                if x1 < 0:
+                    x1 = 0
+                x2 = int(bounding_box[0] + bounding_box[2] + margin_x)
+                if x2 > image.shape[1]:
+                    x2 = image.shape[1]
+                y1 = int(bounding_box[1] - margin_y)
+                if y1 < 0:
+                    y1 = 0
+                y2 = int(bounding_box[1] + bounding_box[3] + margin_y)
+                if y2 > image.shape[0]:
+                    y2 = image.shape[0]
+                print(x1, y1, x2, y2)
+                crop_image = image[y1:y2, x1:x2]
+                new_filename = '{}-{:02d}.png'.format(os.path.join(faces_path, get_filename_only(frame)), count)
+                count = count + 1
+                cv2.imwrite(new_filename, cv2.cvtColor(crop_image, cv2.COLOR_RGB2BGR))
+            else:
+                print('Skipped a face..')
+    

01b-crop_faces_with_azure-vision-api.py

@@ -0,0 +1,89 @@
+import cv2
+import sys, os.path
+import json
+import http.client, urllib.request, urllib.parse, urllib.error, base64
+
+base_path = '.\\train_sample_videos\\'
+AZURE_COMPUTER_VISION_NAME = '----REPLACE-WITH-YOUR-SERVICE-NAME----'  # e.g. xxxxxxxxxx.cognitiveservices.azure.com
+AZURE_COMPUTER_VISION_API_KEY = '----REPLACE-WITH-YOUR-KEY----'
+
+def get_filename_only(file_path):
+    file_basename = os.path.basename(file_path)
+    filename_only = file_basename.split('.')[0]
+    return filename_only
+
+with open(os.path.join(base_path, 'metadata.json')) as metadata_json:
+    metadata = json.load(metadata_json)
+    print(len(metadata))
+
+for filename in metadata.keys():
+    tmp_path = os.path.join(base_path, get_filename_only(filename))
+    print('Processing Directory: ' + tmp_path)
+    frame_images = [x for x in os.listdir(tmp_path) if os.path.isfile(os.path.join(tmp_path, x))]
+    faces_path = os.path.join(tmp_path, 'faces')
+    print('Creating Directory: ' + faces_path)
+    os.makedirs(faces_path, exist_ok=True)
+    print('Cropping Faces from Images...')
+
+    for frame in frame_images:
+        print('Processing ', frame)
+        image = cv2.cvtColor(cv2.imread(os.path.join(tmp_path, frame)), cv2.COLOR_BGR2RGB)
+
+        # Open the binary file
+        with open(os.path.join(tmp_path, frame), 'rb') as file_contents:
+            img_data = file_contents.read()
+
+        ######### Azure Computer Vision API
+        headers = {
+            # Request headers
+            'Content-Type': 'application/octet-stream',
+            'Ocp-Apim-Subscription-Key': AZURE_COMPUTER_VISION_API_KEY,
+        }
+
+        params = urllib.parse.urlencode({
+            # Request parameters
+            'visualFeatures': 'Faces'
+        })
+
+        try:
+            conn = http.client.HTTPSConnection(AZURE_COMPUTER_VISION_NAME)
+            conn.request("POST", "/vision/v3.0/analyze?%s" % params, img_data, headers)
+            response = conn.getresponse().read()
+            data = json.loads(response.decode('utf-8'))
+            print(data)
+            conn.close()
+        except Exception as e:
+            print("[Errno {0}] {1}".format(e.errno, e.strerror))
+            continue
+        
+        print(data['faces'])
+        print('Face Detected: ', len(data['faces']))
+        count = 0
+
+        for result in data['faces']:
+            bounding_box = []
+            bounding_box.append(result['faceRectangle']['left'])
+            bounding_box.append(result['faceRectangle']['top'])
+            bounding_box.append(result['faceRectangle']['width'])
+            bounding_box.append(result['faceRectangle']['height'])
+            print(bounding_box)
+
+            margin_x = bounding_box[2] * 0.3  # 30% as the margin
+            margin_y = bounding_box[3] * 0.3  # 30% as the margin
+            x1 = int(bounding_box[0] - margin_x)
+            if x1 < 0:
+                x1 = 0
+            x2 = int(bounding_box[0] + bounding_box[2] + margin_x)
+            if x2 > image.shape[1]:
+                x2 = image.shape[1]
+            y1 = int(bounding_box[1] - margin_y)
+            if y1 < 0:
+                y1 = 0
+            y2 = int(bounding_box[1] + bounding_box[3] + margin_y)
+            if y2 > image.shape[0]:
+                y2 = image.shape[0]
+            print(x1, y1, x2, y2)
+            crop_image = image[y1:y2, x1:x2]
+            new_filename = '{}-{:02d}.png'.format(os.path.join(faces_path, get_filename_only(frame)), count)
+            count = count + 1
+            cv2.imwrite(new_filename, cv2.cvtColor(crop_image, cv2.COLOR_RGB2BGR))

02-prepare_fake_real_dataset.py

@@ -0,0 +1,65 @@
+import json
+import os
+from distutils.dir_util import copy_tree
+import shutil
+import numpy as np
+import splitfolders as split_folders
+
+base_path = '.\\train_sample_videos\\'
+dataset_path = '.\\prepared_dataset\\'
+print('Creating Directory: ' + dataset_path)
+os.makedirs(dataset_path, exist_ok=True)
+
+tmp_fake_path = '.\\tmp_fake_faces'
+print('Creating Directory: ' + tmp_fake_path)
+os.makedirs(tmp_fake_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
+
+with open(os.path.join(base_path, 'metadata.json')) as metadata_json:
+    metadata = json.load(metadata_json)
+    print(len(metadata))
+
+real_path = os.path.join(dataset_path, 'real')
+print('Creating Directory: ' + real_path)
+os.makedirs(real_path, exist_ok=True)
+
+fake_path = os.path.join(dataset_path, 'fake')
+print('Creating Directory: ' + fake_path)
+os.makedirs(fake_path, exist_ok=True)
+
+for filename in metadata.keys():
+    print(filename)
+    print(metadata[filename]['label'])
+    tmp_path = os.path.join(os.path.join(base_path, get_filename_only(filename)), 'faces')
+    print(tmp_path)
+    if os.path.exists(tmp_path):
+        if metadata[filename]['label'] == 'REAL':    
+            print('Copying to :' + real_path)
+            copy_tree(tmp_path, real_path)
+        elif metadata[filename]['label'] == 'FAKE':
+            print('Copying to :' + tmp_fake_path)
+            copy_tree(tmp_path, tmp_fake_path)
+        else:
+            print('Ignored..')
+
+all_real_faces = [f for f in os.listdir(real_path) if os.path.isfile(os.path.join(real_path, f))]
+print('Total Number of Real faces: ', len(all_real_faces))
+
+all_fake_faces = [f for f in os.listdir(tmp_fake_path) if os.path.isfile(os.path.join(tmp_fake_path, f))]
+print('Total Number of Fake faces: ', len(all_fake_faces))
+
+random_faces = np.random.choice(all_fake_faces, len(all_real_faces), replace=False)
+for fname in random_faces:
+    src = os.path.join(tmp_fake_path, fname)
+    dst = os.path.join(fake_path, fname)
+    shutil.copyfile(src, dst)
+
+print('Down-sampling Done!')
+
+# Split into Train/ Val/ Test folders
+split_folders.ratio(dataset_path, output='split_dataset', seed=1377, ratio=(.8, .1, .1)) # default values
+print('Train/ Val/ Test Split Done!')

03-train_cnn.py

@@ -0,0 +1,185 @@
+import json
+import os
+from distutils.dir_util import copy_tree
+import shutil
+import pandas as pd
+
+# 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
+
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+from tensorflow.keras import applications
+from tensorflow.keras.applications import EfficientNetB0
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense, Dropout
+from tensorflow.keras.optimizers import Adam
+from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
+from tensorflow.keras.models import load_model
+
+input_size = 128
+batch_size_num = 32
+train_path = os.path.join(dataset_path, 'train')
+val_path = os.path.join(dataset_path, 'val')
+test_path = os.path.join(dataset_path, 'test')
+
+train_datagen = ImageDataGenerator(
+    rescale = 1/255,    #rescale the tensor values to [0,1]
+    rotation_range = 10,
+    width_shift_range = 0.1,
+    height_shift_range = 0.1,
+    shear_range = 0.2,
+    zoom_range = 0.1,
+    horizontal_flip = True,
+    fill_mode = 'nearest'
+)
+
+train_generator = train_datagen.flow_from_directory(
+    directory = train_path,
+    target_size = (input_size, input_size),
+    color_mode = "rgb",
+    class_mode = "binary",  #"categorical", "binary", "sparse", "input"
+    batch_size = batch_size_num,
+    shuffle = True
+    #save_to_dir = tmp_debug_path
+)
+
+val_datagen = ImageDataGenerator(
+    rescale = 1/255    #rescale the tensor values to [0,1]
+)
+
+val_generator = val_datagen.flow_from_directory(
+    directory = val_path,
+    target_size = (input_size, input_size),
+    color_mode = "rgb",
+    class_mode = "binary",  #"categorical", "binary", "sparse", "input"
+    batch_size = batch_size_num,
+    shuffle = True
+    #save_to_dir = tmp_debug_path
+)
+
+test_datagen = ImageDataGenerator(
+    rescale = 1/255    #rescale the tensor values to [0,1]
+)
+
+test_generator = test_datagen.flow_from_directory(
+    directory = test_path,
+    classes=['fake', 'real'],
+    target_size = (input_size, input_size),
+    color_mode = "rgb",
+    class_mode = None,
+    batch_size = 1,
+    shuffle = False
+)
+
+# Train a CNN classifier
+efficient_net = EfficientNetB0(
+    weights = 'imagenet',
+    input_shape = (input_size, input_size, 3),
+    include_top = False,
+    pooling = 'max'
+)
+
+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(Dense(units = 1, activation = 'sigmoid'))
+model.summary()
+
+# Compile model
+model.compile(optimizer = Adam(learning_rate=0.0001), loss='binary_crossentropy', metrics=['accuracy'])
+
+checkpoint_filepath = '.\\tmp_checkpoint'
+print('Creating Directory: ' + checkpoint_filepath)
+os.makedirs(checkpoint_filepath, exist_ok=True)
+
+custom_callbacks = [
+    EarlyStopping(
+        monitor = 'val_loss',
+        mode = 'min',
+        patience = 5,
+        verbose = 1
+    ),
+    ModelCheckpoint(
+        filepath = os.path.join(checkpoint_filepath, 'best_model.h5'),
+        monitor = 'val_loss',
+        mode = 'min',
+        verbose = 1,
+        save_best_only = True
+    )
+]
+
+# Train network
+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
+)
+print(history.history)
+
+'''
+# Plot results
+import matplotlib.pyplot as plt
+
+acc = history.history['acc']
+val_acc = history.history['val_acc']
+loss = history.history['loss']
+val_loss = history.history['val_loss']
+
+epochs = range(1, len(acc) + 1)
+
+plt.plot(epochs, acc, 'bo', label = 'Training Accuracy')
+plt.plot(epochs, val_acc, 'b', label = 'Validation Accuracy')
+plt.title('Training and Validation Accuracy')
+plt.legend()
+plt.figure()
+
+plt.plot(epochs, loss, 'bo', label = 'Training loss')
+plt.plot(epochs, val_loss, 'b', label = 'Validation Loss')
+plt.title('Training and Validation Loss')
+plt.legend()
+
+plt.show()
+'''
+
+# load the saved model that is considered the best
+best_model = load_model(os.path.join(checkpoint_filepath, 'best_model.h5'))
+
+# Generate predictions
+test_generator.reset()
+
+preds = best_model.predict(
+    test_generator,
+    verbose = 1
+)
+
+test_results = pd.DataFrame({
+    "Filename": test_generator.filenames,
+    "Prediction": preds.flatten()
+})
+print(test_results)

App/app.py

@@ -0,0 +1,346 @@
+import os
+import sys
+import io
+import base64
+import math
+import logging
+import subprocess
+import cv2
+import numpy as np
+import imageio_ffmpeg
+import mediapipe as mp
+from mediapipe.tasks.python import BaseOptions
+from mediapipe.tasks.python.vision import FaceDetector, FaceDetectorOptions
+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(
+    level=logging.INFO,
+    format='%(asctime)s [%(levelname)s] %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
+)
+logger = logging.getLogger(__name__)
+
+app = Flask(__name__)
+app.config['UPLOAD_FOLDER'] = os.path.join(os.path.dirname(__file__), 'uploads')
+app.config['MAX_CONTENT_LENGTH'] = 200 * 1024 * 1024  # 200 MB limit
+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')
+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
+
+# Initialize MediaPipe face detector
+logger.info('Initializing MediaPipe face detector')
+FACE_MODEL_PATH = os.path.join(os.path.dirname(__file__), 'blaze_face_short_range.tflite')
+face_detector_options = FaceDetectorOptions(
+    base_options=BaseOptions(model_asset_path=FACE_MODEL_PATH),
+    min_detection_confidence=0.5
+)
+logger.info('MediaPipe face detector ready')
+
+# In-memory job store: job_id -> {status, result, ...}
+jobs = {}
+
+
+def allowed_file(filename):
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+
+def face_to_base64(face_rgb):
+    face_bgr = cv2.cvtColor(face_rgb, cv2.COLOR_RGB2BGR)
+    _, buffer = cv2.imencode('.png', face_bgr)
+    return base64.b64encode(buffer).decode('utf-8')
+
+
+def reencode_to_h264(input_path, output_path=None):
+    """Re-encode a video to H.264 for browser compatibility. Overwrites in-place if no output_path."""
+    ffmpeg_exe = imageio_ffmpeg.get_ffmpeg_exe()
+    if output_path is None:
+        output_path = input_path
+    tmp = input_path + '.reencode.mp4'
+    cmd = [
+        ffmpeg_exe, '-y', '-i', input_path,
+        '-c:v', 'libx264', '-preset', 'fast',
+        '-movflags', '+faststart', '-pix_fmt', 'yuv420p',
+        tmp
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        logger.error('ffmpeg reencode failed: %s', result.stderr)
+        try:
+            os.remove(tmp)
+        except OSError:
+            pass
+        return False
+    try:
+        os.replace(tmp, output_path)
+    except OSError:
+        os.remove(input_path)
+        os.rename(tmp, output_path)
+    return True
+
+
+def extract_faces_from_video(video_path):
+    logger.info('Extracting faces from video: %s', video_path)
+    faces = []
+    cap = cv2.VideoCapture(video_path)
+    frame_rate = cap.get(cv2.CAP_PROP_FPS)
+    if frame_rate == 0:
+        logger.warning('Could not read frame rate from video')
+        cap.release()
+        return faces
+
+    with FaceDetector.create_from_options(face_detector_options) as face_det:
+        while cap.isOpened():
+            frame_id = cap.get(cv2.CAP_PROP_POS_FRAMES)
+            ret, frame = cap.read()
+            if not ret:
+                break
+            if frame_id % math.floor(frame_rate) == 0:
+                image_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=image_rgb)
+                results = face_det.detect(mp_image)
+                for detection in results.detections:
+                    score = detection.categories[0].score
+                    if len(results.detections) < 2 or score > 0.95:
+                        bbox = detection.bounding_box
+                        bx, by, bw, bh = bbox.origin_x, bbox.origin_y, bbox.width, bbox.height
+                        h, w = image_rgb.shape[:2]
+                        margin_x = int(bw * 0.3)
+                        margin_y = int(bh * 0.3)
+                        x1 = max(0, bx - margin_x)
+                        x2 = min(w, bx + bw + margin_x)
+                        y1 = max(0, by - margin_y)
+                        y2 = min(h, by + bh + margin_y)
+                        crop = image_rgb[y1:y2, x1:x2]
+                        if crop.size > 0:
+                            crop_resized = cv2.resize(crop, (INPUT_SIZE, INPUT_SIZE))
+                            faces.append(crop_resized)
+
+    cap.release()
+    logger.info('Face extraction complete — %d faces found', len(faces))
+    return faces
+
+
+def create_processed_video(video_path, output_path, avg_score):
+    """Re-encode video with face bounding boxes and label drawn on every frame."""
+    logger.info('Creating processed video with bounding boxes: %s', output_path)
+    is_real = avg_score is not None and avg_score > 0.5
+    label = 'REAL' if is_real else 'FAKE'
+    color = (0, 255, 0) if is_real else (0, 0, 255)  # green / red in BGR
+
+    cap = cv2.VideoCapture(video_path)
+    fps = cap.get(cv2.CAP_PROP_FPS) or 30
+    w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+    # Write to a temp file with mp4v codec first
+    temp_path = output_path + '.tmp.mp4'
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(temp_path, fourcc, fps, (w, h))
+
+    if not out.isOpened():
+        logger.error('VideoWriter failed to open: %s', temp_path)
+        cap.release()
+        return
+
+    frame_count = 0
+    with FaceDetector.create_from_options(face_detector_options) as face_det:
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+            image_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=image_rgb)
+            results = face_det.detect(mp_image)
+            for detection in results.detections:
+                conf = detection.categories[0].score
+                if len(results.detections) < 2 or conf > 0.95:
+                    bbox = detection.bounding_box
+                    x, y = max(0, bbox.origin_x), max(0, bbox.origin_y)
+                    bw, bh = bbox.width, bbox.height
+                    cv2.rectangle(frame, (x, y), (x + bw, y + bh), color, 2)
+                    text = f'{label} {conf:.2f}'
+                    cv2.putText(frame, text, (x, y - 10),
+                                cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)
+            out.write(frame)
+            frame_count += 1
+
+    cap.release()
+    out.release()
+    logger.info('Wrote %d frames to temp file, re-encoding to H.264', frame_count)
+
+    # Re-encode to H.264 for browser compatibility
+    if reencode_to_h264(temp_path, output_path):
+        logger.info('Processed video saved (H.264): %s', output_path)
+    else:
+        logger.error('Failed to re-encode processed video')
+
+    # Clean up temp file
+    try:
+        os.remove(temp_path)
+    except OSError:
+        pass
+
+
+def predict_deepfake(faces):
+    if not faces:
+        logger.warning('No faces to predict on')
+        return None, 0, []
+
+    logger.info('Running prediction on %d face(s)', len(faces))
+
+    face_array = np.array(faces, dtype='float32') / 255.0
+    predictions = model.predict(face_array, verbose=0)
+    avg_prediction = float(np.mean(predictions))
+
+    # Build per-face details (up to 3 evenly spaced faces)
+    total = len(faces)
+    if total <= 3:
+        indices = list(range(total))
+    else:
+        indices = [0, total // 2, total - 1]
+
+    faces_detail = []
+    for i in indices:
+        faces_detail.append({
+            'thumbnail': face_to_base64(faces[i]),
+            'score': float(predictions[i][0])
+        })
+
+    logger.info('Prediction complete — avg score: %.4f, faces: %d', avg_prediction, total)
+    return avg_prediction, total, faces_detail
+
+
+def cleanup_old_uploads(exclude=None):
+    """Delete all files in the upload folder except those in exclude."""
+    exclude = set(exclude or [])
+    folder = app.config['UPLOAD_FOLDER']
+    for f in os.listdir(folder):
+        fpath = os.path.join(folder, f)
+        if os.path.isfile(fpath) and fpath not in exclude:
+            try:
+                os.remove(fpath)
+            except PermissionError:
+                pass
+
+
+@app.route('/', methods=['GET'])
+def index():
+    return render_template('index.html')
+
+
+@app.route('/uploads/<filename>')
+def uploaded_video(filename):
+    return send_from_directory(app.config['UPLOAD_FOLDER'], filename, mimetype='video/mp4')
+
+
+def process_video_job(job_id, filepath, unique_name):
+    """Background worker: extract faces, predict, create processed video."""
+    try:
+        logger.info('[Job %s] Starting face detection', job_id)
+        jobs[job_id]['status'] = 'detecting'
+
+        faces = extract_faces_from_video(filepath)
+        avg_score, num_faces, faces_detail = predict_deepfake(faces)
+
+        if avg_score is None:
+            logger.warning('[Job %s] No faces detected', job_id)
+            jobs[job_id].update({
+                'status': 'done',
+                'error': 'No faces detected in the video.',
+                'video_url': f'/uploads/{unique_name}',
+            })
+            return
+
+        is_real = avg_score > 0.5
+        label = 'REAL' if is_real else 'FAKE'
+        confidence = avg_score if is_real else (1 - avg_score)
+
+        # Publish detection results immediately
+        logger.info('[Job %s] Detection done — result: %s, confidence: %.2f%%, faces: %d',
+                    job_id, label, confidence * 100, num_faces)
+        jobs[job_id].update({
+            'status': 'processing_video',
+            'result': label,
+            'confidence': round(confidence * 100, 2),
+            'score': round(avg_score, 4),
+            'num_faces': num_faces,
+            'faces_detail': faces_detail,
+            'video_url': f'/uploads/{unique_name}',
+        })
+
+        # Now generate processed video (results already visible to client)
+        logger.info('[Job %s] Starting video processing', job_id)
+        processed_name = f"processed_{unique_name}"
+        processed_path = os.path.join(app.config['UPLOAD_FOLDER'], processed_name)
+        create_processed_video(filepath, processed_path, avg_score)
+
+        logger.info('[Job %s] Video processing done', job_id)
+        jobs[job_id].update({
+            'status': 'done',
+            'processed_url': f'/uploads/{processed_name}',
+        })
+    except Exception as e:
+        logger.error('[Job %s] Error: %s', job_id, e)
+        jobs[job_id].update({'status': 'done', 'error': str(e)})
+
+
+@app.route('/predict', methods=['POST'])
+def predict():
+    if 'video' not in request.files:
+        return jsonify({'error': 'No video file uploaded.'}), 400
+
+    file = request.files['video']
+    if file.filename == '':
+        return jsonify({'error': 'No file selected.'}), 400
+
+    if not allowed_file(file.filename):
+        return jsonify({'error': 'Invalid file type. Allowed: mp4, avi, mov, mkv, wmv'}), 400
+
+    cleanup_old_uploads()
+
+    ext = secure_filename(file.filename).rsplit('.', 1)[1].lower()
+    unique_name = f"{uuid.uuid4().hex}.{ext}"
+    filepath = os.path.join(app.config['UPLOAD_FOLDER'], unique_name)
+    file.save(filepath)
+    logger.info('Video uploaded: %s (%s)', file.filename, unique_name)
+
+    # Re-encode upload to H.264 so browser can play it
+    logger.info('Re-encoding uploaded video to H.264')
+    reencode_to_h264(filepath)
+
+    job_id = uuid.uuid4().hex
+    logger.info('Created job %s for %s', job_id, unique_name)
+    jobs[job_id] = {'status': 'uploading', 'video_url': f'/uploads/{unique_name}'}
+
+    thread = threading.Thread(target=process_video_job, args=(job_id, filepath, unique_name))
+    thread.start()
+
+    return jsonify({'job_id': job_id, 'video_url': f'/uploads/{unique_name}'})
+
+
+@app.route('/status/<job_id>')
+def job_status(job_id):
+    job = jobs.get(job_id)
+    if not job:
+        return jsonify({'error': 'Job not found'}), 404
+    return jsonify(job)
+
+
+if __name__ == '__main__':
+    logger.info('Starting Flask server on http://0.0.0.0:5000')
+    app.run(debug=True, host='0.0.0.0', port=5000)

App/blaze_face_short_range.tflite

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

App/static/app.jsx

@@ -0,0 +1,274 @@
+const { useState, useRef, useEffect, useCallback } = React;
+
+const STATUS_MESSAGES = {
+    uploading: 'Uploading video\u2026',
+    detecting: 'Detecting faces & predicting deepfake\u2026',
+    processing_video: 'Generating face detection video\u2026',
+};
+
+function barClass(s) { return s > 0.8 ? 'bar-green' : s > 0.2 ? 'bar-orange' : 'bar-red'; }
+function scoreClass(s) { return s > 0.8 ? 'score-green' : s > 0.2 ? 'score-orange' : 'score-red'; }
+
+/* ── Navbar ── */
+function Navbar() {
+    return (
+        <header className="navbar">
+            <div className="logo"><span>DF</span>Detect</div>
+            <nav>
+                <a href="/" className="active">Product</a>
+                <a href="#">Examples</a>
+                <a href="#">Technology</a>
+                <a href="#">FAQ</a>
+            </nav>
+        </header>
+    );
+}
+
+/* ── Upload Area ── */
+function UploadArea({ file, onFileChange }) {
+    const inputRef = useRef();
+    return (
+        <div
+            className={`upload-area${file ? ' has-file' : ''}`}
+            onClick={() => inputRef.current.click()}
+        >
+            <div className="upload-text">
+                Drop a video here or click to upload &mdash; MP4, AVI, MOV, max 200 MB
+            </div>
+            {file && <div className="file-name">{file.name}</div>}
+            <input
+                ref={inputRef}
+                type="file"
+                accept=".mp4,.avi,.mov,.mkv,.wmv"
+                onChange={e => { onFileChange(e.target.files[0] || null); e.target.value = ''; }}
+            />
+        </div>
+    );
+}
+
+/* ── Video Preview ── */
+function VideoPreview({ file, serverUrl }) {
+    const [localUrl, setLocalUrl] = useState(null);
+
+    useEffect(() => {
+        if (file) {
+            const url = URL.createObjectURL(file);
+            setLocalUrl(url);
+            return () => URL.revokeObjectURL(url);
+        }
+        setLocalUrl(null);
+    }, [file]);
+
+    const src = serverUrl || localUrl;
+    return (
+        <div className="video-preview">
+            {src
+                ? <video controls src={src} key={src} />
+                : <div className="preview-placeholder">&#127916;</div>
+            }
+        </div>
+    );
+}
+
+/* ── Status Spinner ── */
+function StatusIndicator({ status }) {
+    if (!status || status === 'done') return null;
+    return (
+        <>
+            <div className="spinner" />
+            <p className="processing-text">{STATUS_MESSAGES[status] || 'Processing\u2026'}</p>
+        </>
+    );
+}
+
+/* ── Video Comparison ── */
+function VideoComparison({ file, processedUrl, isProcessing }) {
+    const [localUrl, setLocalUrl] = useState(null);
+
+    useEffect(() => {
+        if (file) {
+            const url = URL.createObjectURL(file);
+            setLocalUrl(url);
+            return () => URL.revokeObjectURL(url);
+        }
+        setLocalUrl(null);
+    }, [file]);
+
+    if (!processedUrl && !isProcessing) return null;
+    return (
+        <section className="video-compare">
+            <h2>Face Detection</h2>
+            <div className="compare-grid">
+                <div className="compare-item">
+                    {localUrl
+                        ? <video controls src={localUrl} key={localUrl} />
+                        : <div className="preview-placeholder">&#127916;</div>
+                    }
+                    <div className="compare-label original">Original</div>
+                </div>
+                <div className="compare-item">
+                    {processedUrl
+                        ? <video controls src={processedUrl} key={processedUrl} />
+                        : <div className="preview-placeholder"><div className="spinner" /></div>
+                    }
+                    <div className="compare-label detected">
+                        {processedUrl ? 'Detected Faces' : 'Generating\u2026'}
+                    </div>
+                </div>
+            </div>
+        </section>
+    );
+}
+
+/* ── Face Row ── */
+function FaceRow({ face, index }) {
+    const pct = (face.score * 100).toFixed(2);
+    const w = (face.score * 100).toFixed(1);
+    return (
+        <div className="face-row">
+            <img className="face-thumb" src={`data:image/png;base64,${face.thumbnail}`} alt={`Face ${index + 1}`} />
+            <div className="face-info">
+                <div className="face-bar-track">
+                    <div className={`face-bar-fill ${barClass(face.score)}`} style={{ width: `${w}%` }} />
+                </div>
+                <div className={`face-score ${scoreClass(face.score)}`}>{pct}% authentic</div>
+            </div>
+        </div>
+    );
+}
+
+/* ── Results Panel ── */
+function ResultsPanel({ data }) {
+    if (!data || !data.result) return null;
+    const cls = data.result.toLowerCase();
+    return (
+        <section className="results-section">
+            <div className="results-panel">
+                <h2>Results</h2>
+                <p className="results-hint">
+                    Authenticity score: likelihood the face is real.{' '}
+                    <span className="score-red">Red &lt;20%</span>,{' '}
+                    <span className="score-orange">Orange 20-80%</span>,{' '}
+                    <span className="score-green">Green &gt;80%</span>.
+                </p>
+                <div className={`overall-result ${cls}`}>
+                    <div className="overall-label">{data.result}</div>
+                    <div className="overall-details">
+                        Confidence: {data.confidence}%<br />
+                        Model Score: {data.score}<br />
+                        Faces Analyzed: {data.num_faces}
+                    </div>
+                </div>
+                {data.faces_detail && data.faces_detail.map((face, i) => (
+                    <FaceRow key={i} face={face} index={i} />
+                ))}
+            </div>
+        </section>
+    );
+}
+
+/* ── Main App ── */
+function App() {
+    const [file, setFile] = useState(null);
+    const [status, setStatus] = useState(null);
+    const [error, setError] = useState(null);
+    const [result, setResult] = useState(null);
+    const [submitting, setSubmitting] = useState(false);
+    const timerRef = useRef(null);
+
+    const reset = () => { setResult(null); setError(null); setStatus(null); };
+
+    const handleFileChange = (f) => { setFile(f); reset(); };
+
+    const pollJob = useCallback((jobId) => {
+        timerRef.current = setTimeout(async () => {
+            try {
+                const res = await fetch(`/status/${jobId}`);
+                const data = await res.json();
+                setStatus(data.status);
+
+                // Show results as soon as detection is done (processing_video has result fields)
+                if (data.result) {
+                    setResult(prev => ({ ...prev, ...data }));
+                }
+
+                if (data.status === 'done') {
+                    setSubmitting(false);
+                    if (data.error && !data.result) setError(data.error);
+                } else {
+                    pollJob(jobId);
+                }
+            } catch {
+                setSubmitting(false);
+                setStatus(null);
+                setError('Connection lost. Please try again.');
+            }
+        }, 1000);
+    }, []);
+
+    useEffect(() => () => { if (timerRef.current) clearTimeout(timerRef.current); }, []);
+
+    const handleSubmit = async (e) => {
+        e.preventDefault();
+        if (!file) return;
+        reset();
+        setSubmitting(true);
+        setStatus('uploading');
+
+        const fd = new FormData();
+        fd.append('video', file);
+
+        try {
+            const res = await fetch('/predict', { method: 'POST', body: fd });
+            const data = await res.json();
+            if (data.error) {
+                setError(data.error);
+                setSubmitting(false);
+                setStatus(null);
+            } else {
+                pollJob(data.job_id);
+            }
+        } catch {
+            setError('Upload failed. Please try again.');
+            setSubmitting(false);
+            setStatus(null);
+        }
+    };
+
+    return (
+        <>
+            <Navbar />
+
+            <section className="hero">
+                <div className="hero-left">
+                    <h1 className="hero-title">DFDetect</h1>
+                    <p className="hero-desc">
+                        Free deepfake detection tool for videos. Upload a video and get
+                        per-face authenticity scores in seconds. AI-powered synthetic face detection.
+                    </p>
+
+                    <form onSubmit={handleSubmit}>
+                        <UploadArea file={file} onFileChange={handleFileChange} />
+                        <button type="submit" className="btn" disabled={!file || submitting}>
+                            {submitting ? (STATUS_MESSAGES[status] || 'Processing\u2026') : 'Analyze Video'}
+                        </button>
+                    </form>
+
+                    <StatusIndicator status={submitting ? status : null} />
+                    {error && <div className="error-box">{error}</div>}
+                </div>
+
+                <VideoPreview file={file} serverUrl={result?.video_url} />
+            </section>
+
+            <VideoComparison
+                file={file}
+                processedUrl={result?.processed_url}
+                isProcessing={status === 'processing_video'}
+            />
+            <ResultsPanel data={result} />
+        </>
+    );
+}
+
+ReactDOM.createRoot(document.getElementById('root')).render(<App />);

App/static/style.css

@@ -0,0 +1,93 @@
+* { box-sizing: border-box; margin: 0; padding: 0; }
+body {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    background: #0b0b1a;
+    color: #d0d0d0;
+    min-height: 100vh;
+}
+.navbar {
+    display: flex; align-items: center; justify-content: space-between;
+    padding: 16px 40px; background: #0b0b1a; border-bottom: 1px solid #1a1a2e;
+}
+.navbar .logo { font-size: 22px; font-weight: 700; color: #fff; letter-spacing: 0.5px; }
+.navbar .logo span { color: #6c8cff; }
+.navbar nav a {
+    color: #888; text-decoration: none; margin-left: 32px; font-size: 14px; transition: color 0.2s;
+}
+.navbar nav a:hover, .navbar nav a.active { color: #6c8cff; }
+.hero {
+    display: flex; align-items: flex-start; justify-content: space-between;
+    max-width: 1100px; margin: 60px auto 0; padding: 0 40px; gap: 60px;
+}
+.hero-left { flex: 1; max-width: 480px; }
+.hero-title { font-size: 48px; font-weight: 800; color: #fff; line-height: 1.1; margin-bottom: 18px; }
+.hero-desc { font-size: 15px; color: #999; line-height: 1.7; margin-bottom: 32px; }
+.upload-area {
+    border: 2px dashed #2a2a40; border-radius: 12px; padding: 28px;
+    text-align: center; cursor: pointer; transition: border-color 0.3s; margin-bottom: 14px;
+}
+.upload-area:hover { border-color: #6c8cff; }
+.upload-area.has-file { border-color: #4caf50; }
+.upload-text { color: #666; font-size: 14px; }
+.file-name { color: #6c8cff; font-weight: 600; margin-top: 8px; word-break: break-all; font-size: 14px; }
+input[type="file"] { display: none; }
+.btn {
+    display: block; width: 100%; padding: 13px; background: #6c8cff; color: #fff;
+    border: none; border-radius: 10px; font-size: 15px; font-weight: 600; cursor: pointer; transition: background 0.3s;
+}
+.btn:hover { background: #5a7ae6; }
+.btn:disabled { background: #2a2a40; color: #555; cursor: not-allowed; }
+.video-preview { flex: 1; display: flex; justify-content: center; align-items: center; }
+.video-preview video {
+    max-width: 100%; max-height: 400px; border-radius: 12px; border: 1px solid #1e1e35; background: #111122;
+}
+.preview-placeholder {
+    width: 100%; max-width: 460px; height: 280px; border-radius: 12px; background: #111122;
+    border: 1px solid #1e1e35; display: flex; align-items: center; justify-content: center; color: #333; font-size: 48px;
+}
+.spinner {
+    margin: 16px auto; width: 36px; height: 36px; border: 3px solid #1a1a30;
+    border-top: 3px solid #6c8cff; border-radius: 50%; animation: spin 0.7s linear infinite;
+}
+.processing-text { text-align: center; color: #666; font-size: 13px; margin-top: 8px; }
+@keyframes spin { to { transform: rotate(360deg); } }
+.error-box {
+    margin-top: 20px; padding: 16px; background: rgba(244,67,54,0.1); border: 1px solid rgba(244,67,54,0.3);
+    border-radius: 10px; color: #f44336; text-align: center; font-size: 14px;
+}
+.video-compare { max-width: 1100px; margin: 40px auto 0; padding: 0 40px; }
+.video-compare h2 { font-size: 20px; font-weight: 700; color: #fff; margin-bottom: 16px; }
+.compare-grid { display: flex; gap: 24px; }
+.compare-item { flex: 1; text-align: center; }
+.compare-item video {
+    width: 100%; max-height: 360px; border-radius: 12px; border: 1px solid #1e1e35; background: #111122;
+}
+.compare-label { margin-top: 8px; font-size: 13px; font-weight: 600; text-transform: uppercase; letter-spacing: 1px; }
+.compare-label.original { color: #6c8cff; }
+.compare-label.detected { color: #4caf50; }
+.results-section { max-width: 1100px; margin: 50px auto 60px; padding: 0 40px; }
+.results-panel { background: #111122; border: 1px solid #1e1e35; border-radius: 14px; padding: 30px 36px; }
+.results-panel h2 { font-size: 20px; font-weight: 700; color: #fff; margin-bottom: 6px; }
+.results-hint { font-size: 13px; color: #777; margin-bottom: 24px; line-height: 1.5; }
+.overall-result { display: flex; align-items: center; gap: 20px; padding: 20px; border-radius: 12px; margin-bottom: 24px; }
+.overall-result.real { background: rgba(76,175,80,0.08); border: 1px solid rgba(76,175,80,0.3); }
+.overall-result.fake { background: rgba(244,67,54,0.08); border: 1px solid rgba(244,67,54,0.3); }
+.overall-label { font-size: 32px; font-weight: 800; }
+.overall-result.real .overall-label { color: #4caf50; }
+.overall-result.fake .overall-label { color: #f44336; }
+.overall-details { font-size: 14px; color: #aaa; line-height: 1.6; }
+.face-row { display: flex; align-items: center; gap: 16px; padding: 14px 0; border-top: 1px solid #1a1a30; }
+.face-thumb { width: 52px; height: 52px; border-radius: 8px; object-fit: cover; border: 2px solid #222; background: #1a1a2e; }
+.face-info { flex: 1; }
+.face-bar-track { height: 8px; background: #1a1a30; border-radius: 4px; overflow: hidden; margin-bottom: 6px; }
+.face-bar-fill { height: 100%; border-radius: 4px; transition: width 0.6s ease; }
+.bar-green { background: #4caf50; } .bar-orange { background: #ff9800; } .bar-red { background: #f44336; }
+.face-score { font-size: 13px; font-weight: 600; }
+.score-green { color: #4caf50; } .score-orange { color: #ff9800; } .score-red { color: #f44336; }
+@media (max-width: 768px) {
+    .hero { flex-direction: column; padding: 0 20px; margin-top: 30px; gap: 30px; }
+    .hero-left { max-width: 100%; } .hero-title { font-size: 32px; }
+    .results-section { padding: 0 20px; } .results-panel { padding: 20px; }
+    .navbar { padding: 14px 20px; } .navbar nav a { margin-left: 16px; font-size: 13px; }
+    .compare-grid { flex-direction: column; }
+}

App/templates/index.html

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>DFDetect - DeepFake Detector</title>
+    <script src="https://unpkg.com/react@18/umd/react.production.min.js" crossorigin></script>
+    <script src="https://unpkg.com/react-dom@18/umd/react-dom.production.min.js" crossorigin></script>
+    <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>
+    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+</head>
+<body>
+    <div id="root"></div>
+
+    <script type="text/babel" src="/static/app.jsx"></script>
+</body>
+</html>

requirements.txt

@@ -0,0 +1,11 @@
+numpy
+pandas
+tensorflow
+keras>=2.2.0
+opencv-python>=4.1.0
+mtcnn>=0.1.0
+h5py
+split_folders
+flask
+mediapipe
+imageio-ffmpeg