Create final Hugging Face Space snapshot

.dockerignore

@@ -0,0 +1,19 @@
+.git
+.gitignore
+.venv
+.uv-cache
+.idea
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.log
+.DS_Store
+App/uploads
+train_sample_videos
+prepared_dataset
+split_dataset
+mtcnn
+archive.zip
+best_model.keras
+tests

.gitattributes

@@ -0,0 +1,2 @@
+tmp_checkpoint/best_model.keras filter=lfs diff=lfs merge=lfs -text
+App/static/images.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,145 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# agent
+.codex
+
+# 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_*/
+!tmp_checkpoint/
+!tmp_checkpoint/best_model.keras
+!tmp_checkpoint/best_model_phase1.keras
+mtcnn/
+/.conda
+/train_sample_videos
+/split_dataset
+/prepared_dataset
+/App/uploads
+archive.zip

App/app.py

@@ -0,0 +1,354 @@
+import os
+import base64
+import math
+import logging
+import subprocess
+import cv2
+import numpy as np
+import imageio_ffmpeg
+from mtcnn import MTCNN
+from flask import Flask
+from tensorflow.keras.models import load_model
+from tensorflow.keras.applications.efficientnet import preprocess_input
+import keras.src.layers.normalization.batch_normalization as _bn_module
+
+import sys
+from config import preview_face_detector_enabled, resolve_server_port
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s [%(levelname)s] %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S',
+    stream=sys.stderr
+)
+
+# Monkey-patch BatchNormalization to accept legacy renorm kwargs
+_OrigBN = _bn_module.BatchNormalization
+_orig_bn_init = _OrigBN.__init__
+
+
+def _patched_bn_init(self, *args, **kwargs):
+    kwargs.pop('renorm', None)
+    kwargs.pop('renorm_clipping', None)
+    kwargs.pop('renorm_momentum', None)
+    _orig_bn_init(self, *args, **kwargs)
+
+
+_OrigBN.__init__ = _patched_bn_init
+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)
+
+PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+
+
+def resolve_model_path():
+    """Prefer the canonical training output, but tolerate the legacy root copy."""
+    candidates = [
+        os.path.join(PROJECT_ROOT, 'tmp_checkpoint', 'best_model.keras'),
+        os.path.join(PROJECT_ROOT, 'best_model.keras'),
+    ]
+    for candidate in candidates:
+        if os.path.isfile(candidate):
+            return candidate
+    raise FileNotFoundError(
+        'No model file found. Expected one of: '
+        + ', '.join(candidates)
+    )
+
+
+# Load the trained model
+MODEL_PATH = resolve_model_path()
+logger.info('Loading model from %s', MODEL_PATH)
+model = load_model(MODEL_PATH)
+logger.info('Model loaded successfully')
+INPUT_SIZE = 224
+MIN_FACE_SIZE = 90  # same as 02-prepare_fake_real_dataset.py
+
+# Initialize MTCNN face detector (same as training pipeline 01-crop_faces_with_mtcnn.py)
+logger.info('Initializing MTCNN face detector')
+mtcnn_detector = MTCNN()
+logger.info('MTCNN face detector ready')
+
+# Initialize YOLO face detector (for processed video overlay only)
+FACE_MODEL_PATH = os.path.join(os.path.dirname(__file__), 'yolov8n-face.pt')
+
+
+def build_preview_face_detector():
+    if not preview_face_detector_enabled():
+        logger.info('Preview face detector disabled by configuration')
+        return None
+
+    try:
+        from ultralytics import YOLO
+    except ImportError:
+        logger.warning('ultralytics is unavailable; processed preview will fall back to the uploaded video')
+        return None
+
+    logger.info('Initializing YOLO face detector')
+    detector = YOLO(FACE_MODEL_PATH)
+    logger.info('YOLO face detector ready')
+    return detector
+
+
+face_detector = build_preview_face_detector()
+
+# 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 scale_frame(frame):
+    """Scale frame exactly like 00-convert_video_to_image.py"""
+    h, w = frame.shape[:2]
+    if w < 300:
+        scale_ratio = 2
+    elif w > 1900:
+        scale_ratio = 0.33
+    elif w > 1000:
+        scale_ratio = 0.5
+    else:
+        scale_ratio = 1
+    if scale_ratio != 1:
+        new_w = int(w * scale_ratio)
+        new_h = int(h * scale_ratio)
+        frame = cv2.resize(frame, (new_w, new_h), interpolation=cv2.INTER_AREA)
+    return frame
+
+
+def extract_faces_from_video(video_path):
+    """Extract faces using MTCNN — matching training pipeline (01-crop_faces_with_mtcnn.py)."""
+    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
+
+    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:
+            # Step 1: Scale frame (same as 00-convert_video_to_image.py)
+            frame = scale_frame(frame)
+            image_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            h, w = image_rgb.shape[:2]
+
+            # Step 2: MTCNN face detection (same as 01-crop_faces_with_mtcnn.py)
+            results = mtcnn_detector.detect_faces(image_rgb)
+            num_faces = len(results)
+
+            for result in results:
+                bounding_box = result['box']
+                confidence = result['confidence']
+                # Same logic as training: if single face keep it, if multiple only keep > 0.95
+                if num_faces < 2 or confidence > 0.95:
+                    bx, by, bw, bh = bounding_box
+                    margin_x = bw * 0.3
+                    margin_y = bh * 0.3
+                    x1 = int(max(0, bx - margin_x))
+                    x2 = int(min(w, bx + bw + margin_x))
+                    y1 = int(max(0, by - margin_y))
+                    y2 = int(min(h, by + bh + margin_y))
+                    crop = image_rgb[y1:y2, x1:x2]
+                    # Step 3: Filter small faces (same as 02-prepare_fake_real_dataset.py MIN_IMAGE_SIZE=90)
+                    if crop.shape[0] < MIN_FACE_SIZE or crop.shape[1] < MIN_FACE_SIZE:
+                        continue
+                    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, face_scores=None):
+    """Create video with face bounding boxes using ffmpeg drawbox (much faster than OpenCV)."""
+    logger.info('Creating processed video with bounding boxes: %s', output_path)
+
+    if face_detector is None:
+        logger.info('Preview face detector unavailable; re-encoding original video without overlays')
+        reencode_to_h264(video_path, output_path)
+        return
+
+    cap = cv2.VideoCapture(video_path)
+    fps = cap.get(cv2.CAP_PROP_FPS) or 30
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    duration = total_frames / fps if fps > 0 else 0
+
+    # Sample a few frames spread across the video to detect faces
+    sample_count = min(5, max(1, int(duration)))  # ~1 sample per second, max 5
+    sample_positions = [int(i * total_frames / sample_count) for i in range(sample_count)]
+
+    # Collect all face boxes across sampled frames
+    all_boxes = []
+    for pos in sample_positions:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, pos)
+        ret, frame = cap.read()
+        if not ret:
+            continue
+        results = face_detector(frame, verbose=False)[0]
+        for box in results.boxes:
+            if box.conf[0] > 0.5:
+                bx1, by1, bx2, by2 = map(int, box.xyxy[0])
+                all_boxes.append((max(0, bx1), max(0, by1), bx2, by2))
+
+    cap.release()
+
+    # Build ffmpeg drawbox filter from detected boxes
+    ffmpeg_exe = imageio_ffmpeg.get_ffmpeg_exe()
+    if all_boxes:
+        # Use the most common box region (largest by area) for a stable overlay
+        # Deduplicate similar boxes by averaging nearby ones
+        unique_boxes = []
+        for box in all_boxes:
+            merged = False
+            for i, ub in enumerate(unique_boxes):
+                # If boxes overlap significantly, merge them
+                if (abs(box[0] - ub[0]) < 40 and abs(box[1] - ub[1]) < 40 and
+                        abs(box[2] - ub[2]) < 40 and abs(box[3] - ub[3]) < 40):
+                    unique_boxes[i] = (
+                        (ub[0] + box[0]) // 2, (ub[1] + box[1]) // 2,
+                        (ub[2] + box[2]) // 2, (ub[3] + box[3]) // 2
+                    )
+                    merged = True
+                    break
+            if not merged:
+                unique_boxes.append(box)
+
+        drawbox_filters = []
+        for (x1, y1, x2, y2) in unique_boxes:
+            w = x2 - x1
+            h = y2 - y1
+            drawbox_filters.append(f"drawbox=x={x1}:y={y1}:w={w}:h={h}:color=green:t=2")
+        filter_str = ','.join(drawbox_filters)
+    else:
+        filter_str = 'null'
+
+    cmd = [
+        ffmpeg_exe, '-y', '-i', video_path,
+        '-vf', filter_str,
+        '-c:v', 'libx264', '-preset', 'fast',
+        '-movflags', '+faststart', '-pix_fmt', 'yuv420p',
+        output_path
+    ]
+    logger.info('Running ffmpeg with %d face boxes', len(all_boxes))
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        logger.error('ffmpeg drawbox failed: %s', result.stderr[-500:])
+    else:
+        logger.info('Processed video saved: %s', output_path)
+
+
+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 = preprocess_input(np.array(faces, dtype='float32'))
+    predictions = model.predict(face_array, verbose=0)
+    flat_preds = predictions.flatten()
+    # Use top-K mean: average the top 30% of predictions (at least 3)
+    # Rationale: real videos have many high-confidence real frames; fake videos have NONE
+    sorted_desc = np.sort(flat_preds)[::-1]  # highest first
+    k = max(3, int(len(sorted_desc) * 0.3))
+    top_k = sorted_desc[:k]
+    avg_prediction = float(np.mean(top_k))
+    # Write diagnostics to file
+    diag_path = os.path.join(os.path.dirname(__file__), 'diag_log.txt')
+    with open(diag_path, 'a') as f:
+        f.write(f'Raw predictions: min={float(np.min(predictions)):.4f}, max={float(np.max(predictions)):.4f}, top{k}_mean={avg_prediction:.4f}, mean={float(np.mean(predictions)):.4f}\n')
+        f.write(f'All scores (sorted desc): {sorted_desc.tolist()}\n')
+        f.write(f'Top-{k} used: {top_k.tolist()}\n')
+        f.write(f'Num faces: {len(faces)}\n\n')
+    logger.info('Raw predictions: min=%.4f, max=%.4f, top%d_mean=%.4f, mean=%.4f, n=%d',
+                float(np.min(predictions)), float(np.max(predictions)),
+                k, avg_prediction, float(np.mean(flat_preds)), len(flat_preds))
+
+    # Build per-face details (up to 5 faces sorted by relevance)
+    is_real = avg_prediction > 0.5
+    # Sort face indices by score: highest first for REAL, lowest first for FAKE
+    sorted_indices = np.argsort(flat_preds)[::-1] if is_real else np.argsort(flat_preds)
+    indices = sorted_indices[:5].tolist()
+
+    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, len(faces))
+    return avg_prediction, len(faces), 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
+
+
+from route import routes
+app.register_blueprint(routes)
+
+
+if __name__ == '__main__':
+    port = resolve_server_port()
+    logger.info('Starting Flask server on http://0.0.0.0:%s', port)
+    app.run(debug=False, host='0.0.0.0', port=port)

App/config.py

@@ -0,0 +1,24 @@
+import os
+
+
+DEFAULT_APP_PORT = 5001
+
+
+def resolve_server_port(default=DEFAULT_APP_PORT):
+    raw_value = os.getenv('PORT')
+    if raw_value is None:
+        return default
+
+    try:
+        port = int(raw_value)
+    except ValueError:
+        return default
+
+    if 1 <= port <= 65535:
+        return port
+    return default
+
+
+def preview_face_detector_enabled():
+    raw_value = os.getenv('ENABLE_PREVIEW_FACE_DETECTOR', '1').strip().lower()
+    return raw_value not in {'0', 'false', 'no', 'off'}

App/route.py

@@ -0,0 +1,128 @@
+import os
+import logging
+import uuid
+import threading
+from flask import Blueprint, request, render_template, send_from_directory, jsonify
+from werkzeug.utils import secure_filename
+
+logger = logging.getLogger(__name__)
+
+routes = Blueprint('routes', __name__)
+
+
+def _get_app_deps():
+    """Import app-level objects to avoid circular imports."""
+    from app import (
+        app, jobs, allowed_file, cleanup_old_uploads,
+        extract_faces_from_video, predict_deepfake,
+        create_processed_video, reencode_to_h264
+    )
+    return app, jobs, allowed_file, cleanup_old_uploads, \
+        extract_faces_from_video, predict_deepfake, \
+        create_processed_video, reencode_to_h264
+
+
+@routes.route('/', methods=['GET'])
+def index():
+    return render_template('index.html')
+
+
+@routes.route('/uploads/<filename>')
+def uploaded_video(filename):
+    from app import app
+    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."""
+    app, jobs, _, _, extract_faces_from_video, predict_deepfake, \
+        create_processed_video, _ = _get_app_deps()
+    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)
+
+        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}',
+        })
+
+        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)
+
+        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)})
+
+
+@routes.route('/predict', methods=['POST'])
+def predict():
+    app, jobs, allowed_file, cleanup_old_uploads, _, _, _, reencode_to_h264 = _get_app_deps()
+
+    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)
+
+    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}'})
+
+
+@routes.route('/status/<job_id>')
+def job_status(job_id):
+    from app import jobs
+    job = jobs.get(job_id)
+    if not job:
+        return jsonify({'error': 'Job not found'}), 404
+    return jsonify(job)

App/static/Product.jsx

@@ -0,0 +1,216 @@
+/* ── Upload Area ── */
+function UploadArea({ file, onFileChange }) {
+    const inputRef = React.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>
+    );
+}
+
+/* ── 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 ── */
+const VideoComparison = React.memo(function VideoComparison({ file, processedUrl, isProcessing }) {
+    const videoRef = React.useRef(null);
+    const [localUrl, setLocalUrl] = React.useState(null);
+
+    React.useEffect(() => {
+        if (file) {
+            const url = URL.createObjectURL(file);
+            setLocalUrl(url);
+            return () => URL.revokeObjectURL(url);
+        }
+        setLocalUrl(null);
+    }, [file]);
+
+    if (!localUrl) return null;
+    const showProcessed = processedUrl || isProcessing;
+    return (
+        <section className="video-compare">
+            <h2>{showProcessed ? 'Face Detection' : 'Uploaded Video'}</h2>
+            <div className={`compare-grid${showProcessed ? '' : ' single'}`}>
+                <div className="compare-item">
+                    <video ref={videoRef} controls src={localUrl} />
+                    <div className="compare-label original">Original</div>
+                </div>
+                {showProcessed && (
+                    <div className="compare-item">
+                        {processedUrl
+                            ? <video controls src={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>
+    );
+}
+
+/* ── Product Page ── */
+function ProductPage({ file, setFile, status, setStatus, error, setError, result, setResult, submitting, setSubmitting }) {
+    const timerRef = React.useRef(null);
+
+    const reset = () => { setResult(null); setError(null); setStatus(null); };
+    const handleFileChange = (f) => { setFile(f); reset(); };
+
+    const pollJob = React.useCallback((jobId) => {
+        timerRef.current = setTimeout(async () => {
+            try {
+                const res = await fetch(`/status/${jobId}`);
+                const data = await res.json();
+                setStatus(data.status);
+
+                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);
+    }, []);
+
+    React.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 (
+        <>
+            <section className="hero">
+                <div className="hero-left">
+                    <h1 className="hero-title">AI-Deepfake Video Detection</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>
+
+                <div className="hero-right">
+                    <img src="/static/images.png" alt="AI Deepfake Detection" className="hero-image" />
+                </div>
+            </section>
+
+            <VideoComparison
+                file={file}
+                processedUrl={result?.processed_url}
+                isProcessing={submitting}
+            />
+            <ResultsPanel data={result} />
+        </>
+    );
+}

App/static/Technology.jsx

@@ -0,0 +1,249 @@
+/* ── Step Diagram SVG ── */
+function StepDiagram({ number, title, color }) {
+    return (
+        <svg width="80" height="80" viewBox="0 0 80 80" className="step-icon">
+            <circle cx="40" cy="40" r="36" fill="none" stroke={color} strokeWidth="2.5" />
+            <text x="40" y="46" textAnchor="middle" fill={color} fontSize="28" fontWeight="700">{number}</text>
+        </svg>
+    );
+}
+
+/* ── Pipeline Flow Arrow ── */
+function FlowArrow() {
+    return (
+        <div className="flow-arrow">
+            <svg width="40" height="40" viewBox="0 0 40 40">
+                <path d="M10 20 L28 20 M22 13 L30 20 L22 27" fill="none" stroke="#6c8cff" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round"/>
+            </svg>
+        </div>
+    );
+}
+
+/* ── Technology Page ── */
+function TechnologyPage() {
+    const steps = [
+        {
+            number: 1,
+            title: 'Video to Frames',
+            color: '#6c8cff',
+            description: 'Raw training videos are split into individual image frames. One frame is extracted per second of video using OpenCV. Each frame is automatically scaled based on its resolution to normalize image sizes across the dataset.',
+            details: [
+                'Reads MP4 videos from the FaceForensics++ dataset',
+                'Extracts 1 frame per second (at the video\'s native frame rate)',
+                'Auto-scales: 2\u00d7 for small frames (<300px), 0.5\u00d7 for HD, 0.33\u00d7 for Full HD+',
+                'Saves frames as individual JPG images organized by video',
+            ],
+            diagram: (
+                <svg viewBox="0 0 400 120" className="step-illustration">
+                    <rect x="10" y="15" width="90" height="90" rx="8" fill="#1a1a2e" stroke="#6c8cff" strokeWidth="1.5"/>
+                    <polygon points="40,35 40,80 70,57" fill="#6c8cff" opacity="0.8"/>
+                    <text x="55" y="112" textAnchor="middle" fill="#888" fontSize="11">Video</text>
+                    <path d="M115 60 L155 60" stroke="#6c8cff" strokeWidth="2" markerEnd="url(#arrow1)"/>
+                    <defs><marker id="arrow1" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto"><path d="M0,0 L10,5 L0,10 z" fill="#6c8cff"/></marker></defs>
+                    {[0,1,2,3,4].map(i => (
+                        <g key={i}>
+                            <rect x={165 + i*46} y={20 + (i%2)*15} width="38" height="38" rx="4" fill="#1a1a2e" stroke="#4caf50" strokeWidth="1"/>
+                            <text x={184 + i*46} y={44 + (i%2)*15} textAnchor="middle" fill="#4caf50" fontSize="9">F{i+1}</text>
+                        </g>
+                    ))}
+                    <text x="300" y="112" textAnchor="middle" fill="#888" fontSize="11">Extracted Frames (1/sec)</text>
+                </svg>
+            ),
+        },
+        {
+            number: 2,
+            title: 'Face Detection & Cropping',
+            color: '#ff9800',
+            description: 'MTCNN (Multi-task Cascaded Convolutional Network) scans each extracted frame to detect faces. Detected faces are cropped with a 30% margin around the bounding box to preserve context like hair and jawline, which helps the model detect manipulation artifacts.',
+            details: [
+                'Uses MTCNN deep learning face detector for accurate face localization',
+                'Filters low-confidence detections (>95% threshold for multi-face frames)',
+                'Adds 30% margin around each face bounding box',
+                'Crops and saves individual face images for training',
+            ],
+            diagram: (
+                <svg viewBox="0 0 400 120" className="step-illustration">
+                    <rect x="10" y="10" width="100" height="100" rx="6" fill="#1a1a2e" stroke="#444" strokeWidth="1"/>
+                    <circle cx="60" cy="45" r="15" fill="none" stroke="#ff9800" strokeWidth="1.5" strokeDasharray="3,2"/>
+                    <circle cx="60" cy="42" r="6" fill="#ff9800" opacity="0.4"/>
+                    <ellipse cx="60" cy="55" rx="10" ry="6" fill="#ff9800" opacity="0.3"/>
+                    <rect x="35" y="25" width="50" height="50" rx="4" fill="none" stroke="#ff9800" strokeWidth="2"/>
+                    <text x="60" y="112" textAnchor="middle" fill="#888" fontSize="11">Frame + Detection</text>
+                    <path d="M125 55 L165 55" stroke="#ff9800" strokeWidth="2" markerEnd="url(#arrow2)"/>
+                    <defs><marker id="arrow2" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto"><path d="M0,0 L10,5 L0,10 z" fill="#ff9800"/></marker></defs>
+                    <rect x="175" y="20" width="70" height="70" rx="8" fill="#1a1a2e" stroke="#ff9800" strokeWidth="2"/>
+                    <circle cx="210" cy="45" r="12" fill="none" stroke="#ff9800" strokeWidth="1.5"/>
+                    <circle cx="210" cy="42" r="5" fill="#ff9800" opacity="0.5"/>
+                    <ellipse cx="210" cy="52" rx="8" ry="5" fill="#ff9800" opacity="0.4"/>
+                    <text x="210" y="112" textAnchor="middle" fill="#888" fontSize="11">Cropped Face (+30% margin)</text>
+                    <text x="340" y="40" fill="#ff9800" fontSize="11" fontWeight="600">{'\u2713'} 95%+ confidence</text>
+                    <text x="340" y="58" fill="#888" fontSize="10">30% margin padding</text>
+                    <text x="340" y="76" fill="#888" fontSize="10">Context preserved</text>
+                </svg>
+            ),
+        },
+        {
+            number: 3,
+            title: 'Dataset Preparation',
+            color: '#4caf50',
+            description: 'Cropped face images are organized into "real" and "fake" categories based on FaceForensics++ metadata. Small or corrupted images (<90px) are filtered out. The dataset is then split into training (80%), validation (10%), and test (10%) sets using stratified splitting.',
+            details: [
+                'Labels faces as REAL or FAKE using FaceForensics++ CSV metadata',
+                'Filters out low-quality images smaller than 90\u00d790 pixels',
+                'Balances fake samples across manipulation methods (Deepfakes, Face2Face, FaceSwap, NeuralTextures, FaceShifter)',
+                'Splits into train/val/test (80/10/10) with stratified random sampling',
+            ],
+            diagram: (
+                <svg viewBox="0 0 400 120" className="step-illustration">
+                    <g>
+                        <rect x="10" y="15" width="55" height="40" rx="4" fill="rgba(76,175,80,0.15)" stroke="#4caf50" strokeWidth="1.5"/>
+                        <text x="37" y="39" textAnchor="middle" fill="#4caf50" fontSize="11" fontWeight="600">REAL</text>
+                        <rect x="10" y="65" width="55" height="40" rx="4" fill="rgba(244,67,54,0.15)" stroke="#f44336" strokeWidth="1.5"/>
+                        <text x="37" y="89" textAnchor="middle" fill="#f44336" fontSize="11" fontWeight="600">FAKE</text>
+                    </g>
+                    <path d="M80 55 L120 55" stroke="#4caf50" strokeWidth="2" markerEnd="url(#arrow3)"/>
+                    <defs><marker id="arrow3" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto"><path d="M0,0 L10,5 L0,10 z" fill="#4caf50"/></marker></defs>
+                    <rect x="130" y="8" width="100" height="28" rx="4" fill="rgba(76,175,80,0.1)" stroke="#4caf50" strokeWidth="1"/>
+                    <text x="180" y="26" textAnchor="middle" fill="#4caf50" fontSize="10">Train 80%</text>
+                    <rect x="130" y="44" width="100" height="28" rx="4" fill="rgba(255,152,0,0.1)" stroke="#ff9800" strokeWidth="1"/>
+                    <text x="180" y="62" textAnchor="middle" fill="#ff9800" fontSize="10">Val 10%</text>
+                    <rect x="130" y="80" width="100" height="28" rx="4" fill="rgba(108,140,255,0.1)" stroke="#6c8cff" strokeWidth="1"/>
+                    <text x="180" y="98" textAnchor="middle" fill="#6c8cff" fontSize="10">Test 10%</text>
+                    <text x="310" y="30" fill="#888" fontSize="10">{'\u2713'} Min 90\u00d790px filter</text>
+                    <text x="310" y="50" fill="#888" fontSize="10">{'\u2713'} Stratified split</text>
+                    <text x="310" y="70" fill="#888" fontSize="10">{'\u2713'} Multi-method balance</text>
+                    <text x="310" y="90" fill="#888" fontSize="10">{'\u2713'} CSV metadata labels</text>
+                </svg>
+            ),
+        },
+        {
+            number: 4,
+            title: 'CNN Training (EfficientNetB0)',
+            color: '#f44336',
+            description: 'A two-phase transfer learning approach trains an EfficientNetB0-based classifier. Phase 1 freezes the pre-trained ImageNet backbone and trains only the classification head. Phase 2 unfreezes the entire network for fine-tuning with a very low learning rate, achieving ~92% accuracy.',
+            details: [
+                'EfficientNetB0 backbone pre-trained on ImageNet (224\u00d7224 input)',
+                'Phase 1: Frozen base, train head only (lr=1e-3, up to 15 epochs)',
+                'Phase 2: Full fine-tuning (lr=1e-5, up to 30 epochs)',
+                'Data augmentation: rotation, flip, zoom, shift, brightness',
+                'Class weight balancing for imbalanced datasets',
+                'Callbacks: EarlyStopping, ReduceLROnPlateau, ModelCheckpoint',
+                'Output: binary sigmoid \u2014 score > 0.5 = REAL, \u2264 0.5 = FAKE',
+            ],
+            diagram: (
+                <svg viewBox="0 0 400 140" className="step-illustration">
+                    <rect x="10" y="30" width="70" height="80" rx="6" fill="#1a1a2e" stroke="#f44336" strokeWidth="1.5"/>
+                    <text x="45" y="55" textAnchor="middle" fill="#f44336" fontSize="9" fontWeight="600">224\u00d7224</text>
+                    <text x="45" y="70" textAnchor="middle" fill="#888" fontSize="8">Face Input</text>
+                    <text x="45" y="95" textAnchor="middle" fill="#666" fontSize="8">preprocess</text>
+                    <text x="45" y="106" textAnchor="middle" fill="#666" fontSize="8">[-1, 1]</text>
+                    <path d="M90 70 L115 70" stroke="#f44336" strokeWidth="1.5" markerEnd="url(#arrow4)"/>
+                    <rect x="120" y="15" width="100" height="110" rx="6" fill="#1a1a2e" stroke="#ff9800" strokeWidth="1.5"/>
+                    <text x="170" y="35" textAnchor="middle" fill="#ff9800" fontSize="10" fontWeight="600">EfficientNetB0</text>
+                    <text x="170" y="52" textAnchor="middle" fill="#888" fontSize="8">(ImageNet weights)</text>
+                    {[0,1,2,3].map(i => (
+                        <rect key={i} x="135" y={60 + i*14} width="70" height="10" rx="2" fill={`rgba(255,152,0,${0.15 + i*0.1})`} stroke="#ff9800" strokeWidth="0.5"/>
+                    ))}
+                    <defs><marker id="arrow4" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto"><path d="M0,0 L10,5 L0,10 z" fill="#f44336"/></marker></defs>
+                    <path d="M230 70 L255 70" stroke="#f44336" strokeWidth="1.5" markerEnd="url(#arrow4)"/>
+                    <rect x="260" y="25" width="80" height="90" rx="6" fill="#1a1a2e" stroke="#6c8cff" strokeWidth="1.5"/>
+                    <text x="300" y="45" textAnchor="middle" fill="#6c8cff" fontSize="9" fontWeight="600">Head</text>
+                    <text x="300" y="62" textAnchor="middle" fill="#888" fontSize="7">GlobalAvgPool</text>
+                    <text x="300" y="74" textAnchor="middle" fill="#888" fontSize="7">BatchNorm</text>
+                    <text x="300" y="86" textAnchor="middle" fill="#888" fontSize="7">Dense(256)+Dropout</text>
+                    <text x="300" y="98" textAnchor="middle" fill="#888" fontSize="7">Dense(1, sigmoid)</text>
+                    <path d="M350 70 L375 70" stroke="#4caf50" strokeWidth="1.5" markerEnd="url(#arrow5)"/>
+                    <defs><marker id="arrow5" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto"><path d="M0,0 L10,5 L0,10 z" fill="#4caf50"/></marker></defs>
+                    <text x="388" y="65" fill="#4caf50" fontSize="11" fontWeight="700">0\u20131</text>
+                    <text x="388" y="80" fill="#888" fontSize="8">Score</text>
+                </svg>
+            ),
+        },
+    ];
+
+    return (
+        <section className="tech-page">
+            <div className="tech-hero">
+                <h1 className="tech-title">How It Works</h1>
+                <p className="tech-subtitle">
+                    Our deepfake detection pipeline processes videos through four stages — from raw video
+                    to a trained AI model that scores each face for authenticity.
+                </p>
+            </div>
+
+            {/* Pipeline overview */}
+            <div className="pipeline-overview">
+                {steps.map((step, i) => (
+                    <React.Fragment key={step.number}>
+                        <div className="pipeline-step-mini">
+                            <StepDiagram number={step.number} title={step.title} color={step.color} />
+                            <span style={{ color: step.color, fontWeight: 600, fontSize: 13 }}>{step.title}</span>
+                        </div>
+                        {i < steps.length - 1 && <FlowArrow />}
+                    </React.Fragment>
+                ))}
+            </div>
+
+            {/* Detailed steps */}
+            {steps.map((step) => (
+                <div className="tech-step" key={step.number}>
+                    <div className="tech-step-header">
+                        <StepDiagram number={step.number} title={step.title} color={step.color} />
+                        <div>
+                            <h2 className="tech-step-title" style={{ color: step.color }}>
+                                Step {step.number}: {step.title}
+                            </h2>
+                        </div>
+                    </div>
+                    <p className="tech-step-desc">{step.description}</p>
+                    <div className="tech-step-diagram">
+                        {step.diagram}
+                    </div>
+                    <ul className="tech-step-details">
+                        {step.details.map((d, i) => <li key={i}>{d}</li>)}
+                    </ul>
+                </div>
+            ))}
+
+            {/* Inference section */}
+            <div className="tech-step">
+                <div className="tech-step-header">
+                    <svg width="80" height="80" viewBox="0 0 80 80" className="step-icon">
+                        <circle cx="40" cy="40" r="36" fill="none" stroke="#6c8cff" strokeWidth="2.5"/>
+                        <text x="40" y="46" textAnchor="middle" fill="#6c8cff" fontSize="22" fontWeight="700">{'\u25b6'}</text>
+                    </svg>
+                    <div>
+                        <h2 className="tech-step-title" style={{ color: '#6c8cff' }}>
+                            Real-Time Inference
+                        </h2>
+                    </div>
+                </div>
+                <p className="tech-step-desc">
+                    When you upload a video, the app uses YOLOv8 for fast face detection on each frame,
+                    then feeds cropped faces through the trained EfficientNetB0 model. Each face gets an
+                    authenticity score (0 = fake, 1 = real), and the processed video shows bounding boxes
+                    with per-face REAL/FAKE labels overlaid in real time.
+                </p>
+                <div className="tech-step-diagram">
+                    <svg viewBox="0 0 400 80" className="step-illustration">
+                        <rect x="5" y="15" width="65" height="50" rx="6" fill="#1a1a2e" stroke="#6c8cff" strokeWidth="1.5"/>
+                        <text x="37" y="44" textAnchor="middle" fill="#6c8cff" fontSize="9" fontWeight="600">Upload</text>
+                        <path d="M80 40 L105 40" stroke="#6c8cff" strokeWidth="1.5" markerEnd="url(#arrowI)"/>
+                        <rect x="110" y="15" width="65" height="50" rx="6" fill="#1a1a2e" stroke="#ff9800" strokeWidth="1.5"/>
+                        <text x="142" y="38" textAnchor="middle" fill="#ff9800" fontSize="9" fontWeight="600">YOLOv8</text>
+                        <text x="142" y="50" textAnchor="middle" fill="#888" fontSize="7">Face Detect</text>
+                        <path d="M185 40 L210 40" stroke="#ff9800" strokeWidth="1.5" markerEnd="url(#arrowI)"/>
+                        <rect x="215" y="15" width="65" height="50" rx="6" fill="#1a1a2e" stroke="#f44336" strokeWidth="1.5"/>
+                        <text x="247" y="38" textAnchor="middle" fill="#f44336" fontSize="8" fontWeight="600">EfficientNet</text>
+                        <text x="247" y="50" textAnchor="middle" fill="#888" fontSize="7">Predict</text>
+                        <path d="M290 40 L315 40" stroke="#4caf50" strokeWidth="1.5" markerEnd="url(#arrowI)"/>
+                        <rect x="320" y="15" width="70" height="50" rx="6" fill="#1a1a2e" stroke="#4caf50" strokeWidth="1.5"/>
+                        <text x="355" y="38" textAnchor="middle" fill="#4caf50" fontSize="9" fontWeight="600">REAL</text>
+                        <text x="355" y="50" textAnchor="middle" fill="#f44336" fontSize="9" fontWeight="600">FAKE</text>
+                        <defs><marker id="arrowI" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto"><path d="M0,0 L10,5 L0,10 z" fill="#6c8cff"/></marker></defs>
+                    </svg>
+                </div>
+            </div>
+        </section>
+    );
+}

App/static/app.jsx

@@ -0,0 +1,63 @@
+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'; }
+
+/* ── Simple hash-based router ── */
+function useHashRoute() {
+    const [route, setRoute] = useState(window.location.hash || '#/');
+    useEffect(() => {
+        const onHash = () => setRoute(window.location.hash || '#/');
+        window.addEventListener('hashchange', onHash);
+        return () => window.removeEventListener('hashchange', onHash);
+    }, []);
+    return route;
+}
+
+/* ── Navbar ── */
+function Navbar({ route }) {
+    return (
+        <header className="navbar">
+            <div className="logo"><span>AI</span>-Deepfake Video Detection</div>
+            <nav>
+                <a href="#/" className={route === '#/' || route === '' ? 'active' : ''}>Product</a>
+                <a href="#/technology" className={route === '#/technology' ? 'active' : ''}>Technology</a>
+            </nav>
+        </header>
+    );
+}
+
+/* ── 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 route = useHashRoute();
+
+    return (
+        <>
+            <Navbar route={route} />
+            {route === '#/technology' ? (
+                <TechnologyPage />
+            ) : (
+                <ProductPage
+                    file={file} setFile={setFile}
+                    status={status} setStatus={setStatus}
+                    error={error} setError={setError}
+                    result={result} setResult={setResult}
+                    submitting={submitting} setSubmitting={setSubmitting}
+                />
+            )}
+        </>
+    );
+}
+
+ReactDOM.createRoot(document.getElementById('root')).render(<App />);

App/static/style.css

@@ -0,0 +1,147 @@
+* { 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;
+}
+.hero-right { flex: 1; display: flex; justify-content: center; align-items: stretch; }
+.hero-image {
+    width: 100%; height: 100%; border-radius: 14px; border: 1px solid #1e1e35;
+    object-fit: cover; box-shadow: 0 8px 32px rgba(108,140,255,0.10);
+}
+.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-grid.single { justify-content: center; }
+.compare-grid.single .compare-item { max-width: 640px; }
+.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; }
+    .hero-right { display: none; }
+    .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; }
+    .pipeline-overview { flex-direction: column; align-items: center; }
+    .flow-arrow { transform: rotate(90deg); }
+    .tech-step-header { flex-direction: column; align-items: center; text-align: center; }
+    .tech-page { padding: 0 16px; }
+}
+
+/* ── Technology Page ── */
+.tech-page { max-width: 900px; margin: 0 auto; padding: 0 40px 60px; }
+.tech-hero { text-align: center; margin: 50px 0 40px; }
+.tech-title { font-size: 42px; font-weight: 800; color: #fff; margin-bottom: 14px; }
+.tech-subtitle { font-size: 15px; color: #999; line-height: 1.7; max-width: 600px; margin: 0 auto; }
+
+.pipeline-overview {
+    display: flex; align-items: center; justify-content: center; gap: 12px;
+    margin-bottom: 50px; flex-wrap: wrap;
+}
+.pipeline-step-mini {
+    display: flex; flex-direction: column; align-items: center; gap: 8px; text-align: center; width: 110px;
+}
+.flow-arrow { display: flex; align-items: center; color: #6c8cff; }
+
+.tech-step {
+    background: #111122; border: 1px solid #1e1e35; border-radius: 14px;
+    padding: 30px 36px; margin-bottom: 28px;
+}
+.tech-step-header { display: flex; align-items: center; gap: 20px; margin-bottom: 16px; }
+.tech-step-title { font-size: 22px; font-weight: 700; margin-bottom: 4px; }
+.tech-file {
+    font-size: 12px; color: #6c8cff; background: rgba(108,140,255,0.1);
+    padding: 3px 10px; border-radius: 4px; font-family: 'Consolas', monospace;
+}
+.tech-step-desc { font-size: 14px; color: #aaa; line-height: 1.7; margin-bottom: 20px; }
+.tech-step-diagram {
+    background: #0b0b1a; border: 1px solid #1a1a2e; border-radius: 10px;
+    padding: 20px; margin-bottom: 20px; text-align: center; overflow-x: auto;
+}
+.step-illustration { max-width: 100%; height: auto; }
+.step-icon { flex-shrink: 0; }
+.tech-step-details {
+    list-style: none; padding: 0;
+}
+.tech-step-details li {
+    font-size: 13px; color: #bbb; padding: 6px 0 6px 20px; position: relative; line-height: 1.5;
+}
+.tech-step-details li::before {
+    content: '→'; position: absolute; left: 0; color: #6c8cff; font-weight: 700;
+}

App/templates/index.html

@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AI-Deepfake Video Detection</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/Product.jsx"></script>
+    <script type="text/babel" src="/static/Technology.jsx"></script>
+    <script type="text/babel" src="/static/app.jsx"></script>
+</body>
+</html>

Dockerfile

@@ -0,0 +1,34 @@
+FROM python:3.12-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ffmpeg \
+    libgl1 \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender1 \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN useradd -m -u 1000 user
+
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PORT=7860
+
+ENV ENABLE_PREVIEW_FACE_DETECTOR=0
+
+WORKDIR $HOME/app
+
+RUN pip install --no-cache-dir --upgrade pip
+
+COPY --chown=user requirements.txt $HOME/app/requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY --chown=user . $HOME/app
+
+EXPOSE 7860
+
+CMD ["python", "App/app.py"]

README.md

@@ -0,0 +1,359 @@
+---
+title: DeepFake Detect
+emoji: 🎭
+colorFrom: red
+colorTo: gray
+sdk: docker
+app_port: 7860
+short_description: Face-level deepfake video detection with a Docker-based web app.
+---
+
+# DeepFake-Detect
+
+A Python-based deepfake video detection project with two main parts:
+
+1. An offline training pipeline that extracts frames, crops faces, prepares labeled data, and trains a binary classifier.
+2. A Flask web application that accepts uploaded videos, analyzes faces, returns authenticity scores, and generates a processed preview video with face boxes.
+
+The current repository is focused on face-level deepfake detection rather than general-purpose video understanding.
+
+## What This Project Does
+
+- Takes videos as input and samples frames once per second.
+- Uses `MTCNN` to detect and crop faces from extracted frames.
+- Uses FaceForensics++ CSV metadata to label face samples as `REAL` or `FAKE`.
+- Filters out very small face crops and builds `train / val / test` datasets.
+- Trains an `EfficientNetB0`-based classifier with transfer learning and fine-tuning.
+- Provides a Flask web app for interactive video analysis.
+
+## Tech Stack
+
+- Backend: `Flask`
+- Deep learning: `TensorFlow / Keras`
+- Main classifier: `EfficientNetB0`
+- Face detection for training/inference crops: `MTCNN`
+- Face detection for preview overlays: `YOLOv8 face`
+- Video processing: `OpenCV`, `ffmpeg` via `imageio-ffmpeg`
+- Dataset splitting: `split-folders`
+
+## Detection Pipeline
+
+### Training Stage
+
+#### 1. Convert videos to frames
+Script: [00-convert_video_to_image.py](/Users/zhangke/Documents/Projects/DeepFake-Detect/00-convert_video_to_image.py)
+
+- Reads videos from subfolders under `train_sample_videos/FaceForensics++_C23/`.
+- Extracts 1 frame per second.
+- Dynamically rescales each frame based on source resolution:
+  - Width `< 300`: scale to `2x`
+  - Width `> 1900`: scale to `0.33x`
+  - Width `1000 ~ 1900`: scale to `0.5x`
+  - Otherwise: keep original size
+- Stores extracted PNG frames in a per-video directory.
+
+#### 2. Detect and crop faces
+Script: [01-crop_faces_with_mtcnn.py](/Users/zhangke/Documents/Projects/DeepFake-Detect/01-crop_faces_with_mtcnn.py)
+
+- Runs `MTCNN` on every extracted frame.
+- If a frame contains only one face, that detection is kept.
+- If a frame contains multiple faces, only detections with confidence above `0.95` are kept.
+- Expands each bounding box by `30%` to preserve more facial context.
+- Saves cropped faces into a `faces/` subdirectory for each video.
+
+#### 3. Prepare the dataset
+Script: [02-prepare_fake_real_dataset.py](/Users/zhangke/Documents/Projects/DeepFake-Detect/02-prepare_fake_real_dataset.py)
+
+- Reads labels from `csv/*.csv`.
+- Copies face crops into:
+  - `prepared_dataset/real`
+  - `prepared_dataset/fake`
+- Filters out any image with width or height smaller than `90px`.
+- Splits the final dataset with `split-folders` into:
+  - `split_dataset/train`
+  - `split_dataset/val`
+  - `split_dataset/test`
+
+#### 4. Train the classifier
+Script: [03-train_cnn.py](/Users/zhangke/Documents/Projects/DeepFake-Detect/03-train_cnn.py)
+
+- Input size: `224x224`
+- Backbone: `EfficientNetB0(weights="imagenet")`
+- Output: single-unit `sigmoid` binary classifier
+- Training strategy:
+  - Phase 1: freeze the backbone and train only the head with learning rate `1e-3`
+  - Phase 2: unfreeze the full model and fine-tune with learning rate `1e-5`
+- Data augmentation includes:
+  - rotation
+  - horizontal flip
+  - zoom
+  - translation
+  - brightness jitter
+- Uses:
+  - `EarlyStopping`
+  - `ModelCheckpoint`
+  - `ReduceLROnPlateau`
+- Applies class weights to reduce `fake/real` imbalance.
+
+The best trained model is saved to:
+
+```text
+tmp_checkpoint/best_model.keras
+```
+
+This is the canonical model output path used by the training pipeline.
+
+## Web App Inference Flow
+
+App entry point: [App/app.py](/Users/zhangke/Documents/Projects/DeepFake-Detect/App/app.py)
+
+Routes: [App/route.py](/Users/zhangke/Documents/Projects/DeepFake-Detect/App/route.py)
+
+Frontend files:
+
+- [App/templates/index.html](/Users/zhangke/Documents/Projects/DeepFake-Detect/App/templates/index.html)
+- [App/static/app.jsx](/Users/zhangke/Documents/Projects/DeepFake-Detect/App/static/app.jsx)
+- [App/static/Product.jsx](/Users/zhangke/Documents/Projects/DeepFake-Detect/App/static/Product.jsx)
+- [App/static/Technology.jsx](/Users/zhangke/Documents/Projects/DeepFake-Detect/App/static/Technology.jsx)
+
+### Actual inference logic
+
+When a video is uploaded, the backend performs these steps:
+
+1. Validates the file type: `mp4`, `avi`, `mov`, `mkv`, `wmv`
+2. Re-encodes the uploaded video to browser-friendly `H.264`
+3. Reads frames roughly once per second
+4. Uses `MTCNN` to extract faces for classification
+5. Runs `EfficientNetB0` inference on each face crop
+6. Sorts all face scores from highest to lowest and averages the top `30%`
+7. If the averaged score is `> 0.5`, the video is labeled `REAL`; otherwise `FAKE`
+8. Returns:
+   - final label
+   - confidence
+   - model score
+   - number of faces analyzed
+   - face thumbnails with per-face scores
+9. Uses `YOLOv8 face` to generate a preview video with face bounding boxes
+
+Notes:
+
+- `MTCNN` is used for the actual face crops fed into the classifier.
+- `YOLOv8 face` is currently used for visualization in the processed preview video, not as the classifier itself.
+
+## Repository Structure
+
+```text
+DeepFake-Detect/
+├── 00-convert_video_to_image.py
+├── 01-crop_faces_with_mtcnn.py
+├── 02-prepare_fake_real_dataset.py
+├── 03-train_cnn.py
+├── tmp_checkpoint/
+│   ├── best_model.keras
+│   └── best_model_phase1.keras
+├── App/
+│   ├── app.py
+│   ├── route.py
+│   ├── yolov8n-face.pt
+│   ├── static/
+│   └── templates/
+├── train_sample_videos/
+│   └── FaceForensics++_C23/
+├── best_model.keras
+├── pyproject.toml
+└── uv.lock
+```
+
+## Dataset Layout
+
+The training scripts expect the dataset root at:
+
+```text
+train_sample_videos/FaceForensics++_C23/
+```
+
+The repository currently contains these visible subdirectories:
+
+- `original`
+- `Deepfakes`
+- `DeepFakeDetection`
+- `Face2Face`
+- `FaceSwap`
+- `FaceShifter`
+- `NeuralTextures`
+- `csv`
+
+CSV files include fields such as:
+
+- `File Path`
+- `Label`
+- `Frame Count`
+- `Width`
+- `Height`
+- `Codec`
+- `File Size(MB)`
+
+## Requirements
+
+- Python `>= 3.12`
+- `uv` is recommended
+- For training, an NVIDIA GPU that TensorFlow can detect is strongly recommended
+- For the web app, a working `ffmpeg` runtime is required; the project accesses it through `imageio-ffmpeg`
+
+## Install Dependencies
+
+### Option 1: use uv
+
+```bash
+uv sync
+```
+
+### Option 2: use venv + pip
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+## Quick Start
+
+### 1. Prepare the model file
+
+The web app resolves the model in this order:
+
+```text
+tmp_checkpoint/best_model.keras
+best_model.keras
+```
+
+`tmp_checkpoint/best_model.keras` is the canonical location. The root-level `best_model.keras` is treated as a compatibility fallback only.
+
+If you want the project to use the standard training output path, place the model here:
+
+```bash
+mkdir -p tmp_checkpoint
+cp best_model.keras tmp_checkpoint/best_model.keras
+```
+
+If you want to train from scratch, follow the training sequence below. The training script will generate this file automatically.
+
+### 2. Start the web app
+
+```bash
+uv run python App/app.py
+```
+
+Then open:
+
+```text
+http://127.0.0.1:5001
+```
+
+The app now defaults to port `5001`. You can override it with an environment variable:
+
+```bash
+PORT=5050 uv run python App/app.py
+```
+
+## Hugging Face Spaces Deployment
+
+This repository is now prepared for a Docker-based Hugging Face Space.
+
+Deployment files:
+
+- [Dockerfile](/Users/zhangke/Documents/Projects/DeepFake-Detect/Dockerfile)
+- [.dockerignore](/Users/zhangke/Documents/Projects/DeepFake-Detect/.dockerignore)
+- [requirements.txt](/Users/zhangke/Documents/Projects/DeepFake-Detect/requirements.txt)
+
+The Space configuration is defined in the YAML header at the top of this README:
+
+- `sdk: docker`
+- `app_port: 7860`
+
+Container runtime behavior:
+
+- The container runs the Flask app with `python App/app.py`
+- The Docker image sets `PORT=7860`
+- The Docker image sets `ENABLE_PREVIEW_FACE_DETECTOR=0`
+- The app itself already supports `PORT`, so it matches Hugging Face Spaces routing
+
+Recommended deployment steps:
+
+1. Create a new Hugging Face Space and choose `Docker` as the SDK.
+2. Push this repository to that Space repository.
+3. Wait for the image build to complete.
+4. Open the Space once the container becomes healthy.
+
+Notes for this project on Spaces:
+
+- The Docker build excludes local training data and the duplicate root-level `best_model.keras` from the build context.
+- The canonical runtime model remains `tmp_checkpoint/best_model.keras`.
+- The app uses CPU by default unless you assign GPU hardware to the Space.
+- To keep the Docker image smaller and easier to build, the Space disables YOLO-based preview overlays by default and falls back to a re-encoded original video.
+
+Local Docker smoke test:
+
+```bash
+docker build -t deepfake-detect-space .
+docker run --rm -p 7860:7860 deepfake-detect-space
+```
+
+Then open:
+
+```text
+http://127.0.0.1:7860
+```
+
+## Training Order
+
+To reproduce the full training pipeline, run the scripts in this order:
+
+```bash
+uv run python 00-convert_video_to_image.py
+uv run python 01-crop_faces_with_mtcnn.py
+uv run python 02-prepare_fake_real_dataset.py
+uv run python 03-train_cnn.py
+```
+
+## Key Outputs
+
+- Frame extraction output: per-video frame folders
+- Face crops: `faces/` inside each processed video folder
+- Aggregated dataset: `prepared_dataset/`
+- Train/validation/test splits: `split_dataset/`
+- Trained model: `tmp_checkpoint/best_model.keras`
+- Phase 1 checkpoint: `tmp_checkpoint/best_model_phase1.keras`
+- Compatibility fallback model: `best_model.keras`
+- Web upload directory: `App/uploads/`
+- Inference diagnostics log: `App/diag_log.txt`
+
+## Important Implementation Details
+
+These details matter when understanding the current system:
+
+- This is a face-crop-based binary classifier, not an end-to-end video transformer.
+- The model score semantics are: values closer to `1` mean more likely real, values closer to `0` mean more likely fake.
+- The video-level decision is not a plain average across all faces; it uses the mean of the highest-scoring subset.
+- The upload endpoint enforces a `200 MB` limit.
+- The app cleans old uploaded files, so `App/uploads/` should not be treated as persistent storage.
+
+## Known Limitations
+
+- Both training and inference depend heavily on face detection quality.
+- The current sampling strategy uses only 1 frame per second, which may miss short-lived manipulation artifacts.
+- The repository does not currently provide a standalone CLI inference script; the primary entry point is the Flask app.
+- The canonical model path is `tmp_checkpoint/best_model.keras`, but the app also supports `best_model.keras` in the repository root as a fallback.
+- This README is based on the current codebase behavior. If UI text and code behavior differ, trust the code.
+
+## Possible Next Improvements
+
+- Add a CLI inference entry point
+- Move paths, thresholds, and input/output directories into configuration
+- Persist training metrics and experiment logs
+- Add batch video inference support
+- Add Docker and deployment documentation
+
+## License
+
+No explicit license file is present in the repository at the moment. If you plan to publish or use this project commercially, add a proper license first.

requirements.txt

@@ -0,0 +1,12 @@
+flask>=3.1.3
+h5py>=3.14.0
+imageio-ffmpeg>=0.6.0
+mtcnn>=0.1.0
+numpy>=2.4.4
+opencv-python>=4.1.0
+pandas>=3.0.2
+pillow>=12.2.0
+scikit-learn>=1.8.0
+split-folders>=0.6.1
+tensorflow==2.21.0
+werkzeug>=3.1.8

tmp_checkpoint/best_model.keras

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