Upload 25 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+best_model.keras filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,12 +1,25 @@
----
-title: Interactive Human Vs AIDetector Game
-emoji: 📊
-colorFrom: yellow
-colorTo: green
-sdk: gradio
-sdk_version: 6.3.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Real vs AI Face Detection Game
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 5.0.0
+app_file: app.py
+pinned: false
+---
+
+# 🤖 Human vs. AI: Face Detection Showdown
+
+Can you distinguish real human faces from AI-generated ones better than a Deep Learning model?
+
+## 🎮 How to Play
+1. A face image will appear.
+2. Click **Real** or **AI** to make your guess.
+3. See if you were right, and check if the AI Model got it right too!
+4. Compete to see who gets a higher score.
+
+## 🧠 Behind the Scenes
+This game is powered by a **Convolutional Neural Network (CNN)** trained on a dataset of real and fake faces. 
+
+*Student Project for CS6180 - Deep Learning*

app.py

@@ -0,0 +1,212 @@
+import gradio as gr
+import tensorflow as tf
+import numpy as np
+import os
+import random
+from PIL import Image
+
+# --- Config ---
+# Get the absolute path of the directory containing this script
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+MODEL_PATH = os.path.join(BASE_DIR, "best_model.keras")
+IMAGE_FOLDER = os.path.join(BASE_DIR, "test_images")
+IMG_SIZE = (128, 128)
+
+# --- Global State Helpers ---
+def load_game_resources():
+    """Loads model and image list."""
+    # Load Model
+    try:
+        model = tf.keras.models.load_model(MODEL_PATH)
+        print("✅ Model loaded successfully.")
+    except Exception as e:
+        print(f"❌ Error loading model: {e}")
+        model = None
+
+    # Load Images
+    images = []
+    if os.path.exists(IMAGE_FOLDER):
+        for fname in os.listdir(IMAGE_FOLDER):
+            if fname.lower().endswith(('.png', '.jpg', '.jpeg')):
+                path = os.path.join(IMAGE_FOLDER, fname)
+                # Determine label from filename prefix created in prepare_assets.py
+                label = "Real" if "real_" in fname.lower() else "AI"
+                images.append((path, label))
+    
+    random.shuffle(images)
+    print(f"✅ Loaded {len(images)} images.")
+    return model, images
+
+# Load resources once on startup
+global_model, global_images = load_game_resources()
+
+# --- Game Logic ---
+
+def start_new_game():
+    """Reset scores and reshuffle images."""
+    random.shuffle(global_images)
+    # State: [human_score, model_score, round_count, current_image_index, image_list]
+    return 0, 0, 0, 0, global_images, gr.update(visible=True), gr.update(visible=False)
+
+def get_current_image(index, image_list):
+    if not image_list or index >= len(image_list):
+        return None, "Game Over! Restart to play again.", None
+    
+    path, label = image_list[index]
+    return path, f"Round {index + 1}", label
+
+def predict_and_score(user_guess, index, image_list, human_score, model_score, rounds):
+    if not image_list or index >= len(image_list):
+        return human_score, model_score, rounds, index, "Game Over", None, gr.update(visible=False), gr.update(visible=True)
+
+    path, true_label = image_list[index]
+    
+    # 1. Model Prediction
+    model_guess_label = "Unsure"
+    confidence = 0.0
+    
+    if global_model:
+        try:
+            img = Image.open(path).convert('RGB')
+            img = img.resize(IMG_SIZE)
+            img_array = np.array(img) / 255.0
+            img_array = np.expand_dims(img_array, axis=0)
+            
+            # Prediction (Sigmoid: <0.5 = Class 0, >0.5 = Class 1)
+            # We need to know which class is which. 
+            # Usually: 0=AI, 1=Real OR 0=Real, 1=AI.
+            # In the notebook: train_generator.class_indices would tell us.
+            # Assumption based on directory names: sorting usually puts AI first.
+            # So 0=AI, 1=Real. Let's verify this output if possible, but assume 0=AI for now.
+            prediction = global_model.predict(img_array, verbose=0)[0][0]
+            
+            # Notebook typically uses 'training_AI' and 'training_real'. 
+            # Alphabetical: AI=0, real=1.
+            is_real = prediction > 0.5
+            model_guess_label = "Real" if is_real else "AI"
+            confidence = prediction if is_real else 1 - prediction
+            
+        except Exception as e:
+            print(f"Prediction Error: {e}")
+            model_guess_label = "Error"
+    
+    # 2. Update Scores
+    human_correct = (user_guess == true_label)
+    model_correct = (model_guess_label == true_label)
+    
+    if human_correct:
+        human_score += 1
+    if model_correct:
+        model_score += 1
+        
+    rounds += 1
+    next_idx = index + 1
+    
+    # 3. Message
+    result_text = f"## Result: {true_label}!\n\n"
+    result_text += f"**You guessed:** {user_guess} " + ("✅" if human_correct else "❌") + "\n"
+    result_text += f"**Model guessed:** {model_guess_label} " + ("✅" if model_correct else "❌") + f" ({confidence:.2f})"
+
+    # Prepare next round view
+    # Hide guess buttons, Show Next button
+    return human_score, model_score, rounds, next_idx, result_text, gr.update(visible=False), gr.update(visible=True) 
+
+def next_round_view(index, image_list):
+    path, round_text, _ = get_current_image(index, image_list)
+    if path is None:
+         return None, round_text, gr.update(visible=False), gr.update(visible=False), gr.update(visible=True) # End game
+    
+    return path, round_text, gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
+
+# --- UI Construction ---
+with gr.Blocks() as demo:
+    
+    # Game State
+    # Stores: [human_score, model_score, rounds, index, image_list]
+    state_human = gr.State(0)
+    state_model = gr.State(0)
+    state_rounds = gr.State(0)
+    state_index = gr.State(0)
+    state_images = gr.State(global_images)
+
+    gr.Markdown("# 🤖 Human vs. AI: Face Detection Showdown")
+    gr.Markdown("Can you beat the deep learning model at spotting AI-generated faces?")
+    
+    with gr.Row():
+        # Left Column: Stats
+        with gr.Column(scale=1):
+            human_score_disp = gr.Number(label="Your Score", value=0)
+            model_score_disp = gr.Number(label="Model Score", value=0)
+            round_disp = gr.Number(label="Rounds Played", value=0)
+            restart_btn = gr.Button("🔄 Restart Game", variant="secondary")
+
+        # Right Column: Game Area
+        with gr.Column(scale=2):
+            round_label = gr.Markdown("### Round 1")
+            image_display = gr.Image(label="Is this face Real or AI?", type="filepath", height=300)
+            
+            result_box = gr.Markdown("")
+            
+            with gr.Row() as guess_row:
+                btn_real = gr.Button("Real 👤", variant="primary", size="lg")
+                btn_ai = gr.Button("AI 🤖", variant="primary", size="lg")
+            
+            next_btn = gr.Button("Next Image ➡️", variant="primary", visible=False)
+
+    # --- Event Handlers ---
+    
+    # Restart
+    restart_btn.click(
+        start_new_game,
+        outputs=[state_human, state_model, state_rounds, state_index, state_images, guess_row, next_btn]
+    ).then(
+        next_round_view,
+        inputs=[state_index, state_images],
+        outputs=[image_display, round_label, guess_row, next_btn, restart_btn]
+    ).then(
+        lambda: (0,0,0, ""), outputs=[human_score_disp, model_score_disp, round_disp, result_box]
+    )
+
+    # Guess Real
+    btn_real.click(
+        fn=predict_and_score,
+        inputs=[gr.State("Real"), state_index, state_images, state_human, state_model, state_rounds],
+        outputs=[state_human, state_model, state_rounds, state_index, result_box, guess_row, next_btn]
+    ).then(
+        lambda h, m, r: (h, m, r),
+        inputs=[state_human, state_model, state_rounds],
+        outputs=[human_score_disp, model_score_disp, round_disp]
+    )
+    
+    # Guess AI
+    btn_ai.click(
+        fn=predict_and_score,
+        inputs=[gr.State("AI"), state_index, state_images, state_human, state_model, state_rounds],
+        outputs=[state_human, state_model, state_rounds, state_index, result_box, guess_row, next_btn]
+    ).then(
+        lambda h, m, r: (h, m, r),
+        inputs=[state_human, state_model, state_rounds],
+        outputs=[human_score_disp, model_score_disp, round_disp]
+    )
+
+    # Next Image
+    next_btn.click(
+        next_round_view,
+        inputs=[state_index, state_images],
+        outputs=[image_display, round_label, guess_row, next_btn, restart_btn]
+    ).then(
+        lambda: "", outputs=[result_box]
+    )
+
+    # Initial Load
+    demo.load(
+        start_new_game,
+        outputs=[state_human, state_model, state_rounds, state_index, state_images, guess_row, next_btn]
+    ).then(
+        next_round_view,
+        inputs=[state_index, state_images],
+        outputs=[image_display, round_label, guess_row, next_btn, restart_btn]
+    )
+
+if __name__ == "__main__":
+    demo.launch(theme=gr.themes.Soft())

best_model.keras

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

requirements.txt

@@ -0,0 +1,5 @@
+tensorflow
+gradio
+numpy
+pillow
+h5py

verify_model.py

@@ -0,0 +1,33 @@
+
+import tensorflow as tf
+import numpy as np
+import os
+
+MODEL_PATH = "best_model.keras"
+IMG_SIZE = (128, 128)
+
+def verify():
+    if not os.path.exists(MODEL_PATH):
+        print(f"❌ Model not found at {MODEL_PATH}")
+        return
+
+    try:
+        model = tf.keras.models.load_model(MODEL_PATH)
+        print("✅ Model loaded successfully.")
+        
+        # Print input shape
+        input_shape = model.input_shape
+        print(f"Model Input Shape: {input_shape}")
+        
+        # Test Prediction
+        dummy_input = np.random.rand(1, IMG_SIZE[0], IMG_SIZE[1], 3).astype(np.float32)
+        print(f"Testing with input shape: {dummy_input.shape}")
+        
+        prediction = model.predict(dummy_input, verbose=0)
+        print(f"✅ Prediction Check: Output shape {prediction.shape}, Value: {prediction}")
+        
+    except Exception as e:
+        print(f"❌ Error: {e}")
+
+if __name__ == "__main__":
+    verify()